From 6940b2c7f57980200f804bbfc039f2edcef19eb8 Mon Sep 17 00:00:00 2001 From: Yogthos Date: Sun, 28 Jun 2026 01:40:51 -0400 Subject: [PATCH 1/7] corpus: certify seq realization order, count, and memoization The corpus compares values, so eager-vs-lazy was invisible (identical values). Add rows that reduce laziness to a value via a side-effect counter: realization order (map/filter left-to-right), exact realization count under take/nth/drop (no over-realization), and lazy-seq memoization (realize-once across repeated walks). Sourced through unchunked producers (iterate, lists) so jolt's unchunked model matches the JVM. All certify against Clojure 1.12.5. --- test/chez/corpus.edn | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/test/chez/corpus.edn b/test/chez/corpus.edn index 2b8e062..7fe562e 100644 --- a/test/chez/corpus.edn +++ b/test/chez/corpus.edn @@ -794,6 +794,13 @@ {:suite "lazy-seq / realization is shared across walks" :label "effects run once across three walks" :expected "3" :actual "(let [a (atom 0) s (map (fn [x] (swap! a inc) x) [1 2 3])] (doall s) (dorun s) (vec s) (deref a))"} {:suite "lazy-seq / realization is shared across walks" :label "values stable across walks" :expected "true" :actual "(let [s (map inc [1 2 3])] (= (vec s) (vec s) [2 3 4]))"} {:suite "lazy-seq / realization is shared across walks" :label "filter effects once" :expected "4" :actual "(let [a (atom 0) s (filter (fn [x] (swap! a inc) (odd? x)) [1 2 3 4])] (dorun s) (count s) (deref a))"} + {:suite "lazy / realization order & count" :label "map realizes left-to-right" :expected "[1 2 3]" :actual "(let [log (atom [])] (dorun (map (fn [x] (swap! log conj x) x) (list 1 2 3))) @log)"} + {:suite "lazy / realization order & count" :label "filter realizes left-to-right" :expected "[1 2 3]" :actual "(let [log (atom [])] (dorun (filter (fn [x] (swap! log conj x) true) (list 1 2 3))) @log)"} + {:suite "lazy / realization order & count" :label "take realizes exactly n, no over-realization" :expected "3" :actual "(let [a (atom 0)] (dorun (take 3 (map (fn [x] (swap! a inc) x) (iterate inc 0)))) @a)"} + {:suite "lazy / realization order & count" :label "nth realizes exactly index+1" :expected "3" :actual "(let [a (atom 0)] (nth (map (fn [x] (swap! a inc) x) (iterate inc 0)) 2) @a)"} + {:suite "lazy / realization order & count" :label "drop+first realizes through the index" :expected "3" :actual "(let [a (atom 0)] (first (drop 2 (map (fn [x] (swap! a inc) x) (iterate inc 0)))) @a)"} + {:suite "lazy / realization is memoized" :label "first twice realizes once" :expected "1" :actual "(let [a (atom 0) s (map (fn [x] (swap! a inc) x) (iterate inc 0))] (first s) (first s) @a)"} + {:suite "lazy / realization is memoized" :label "wider take extends, does not re-realize" :expected "4" :actual "(let [a (atom 0) s (map (fn [x] (swap! a inc) x) (iterate inc 0))] (doall (take 2 s)) (doall (take 4 s)) @a)"} {:suite "list / construct & predicate" :label "list" :expected "[1 2 3]" :actual "(list 1 2 3)"} {:suite "list / construct & predicate" :label "empty list" :expected "[]" :actual "(list)"} {:suite "list / construct & predicate" :label "quoted list" :expected "[1 2 3]" :actual "(quote (1 2 3))"} From 6d441e2d0006b96dc513e1cdb70c9f6419272c79 Mon Sep 17 00:00:00 2001 From: Yogthos Date: Sun, 28 Jun 2026 01:56:26 -0400 Subject: [PATCH 2/7] chunk-first: pull the trie leaf instead of flattening the whole vector MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A pvec is a 32-way trie, but na-chunk-first built each block by calling pvec-v on the full backing vector — materializing all n elements to a flat Scheme vector — then copying the 32-wide window out of it. That made chunk-first O(n), so walking a vector chunk-by-chunk (Clojure's real chunked map/filter fast path) was O(n^2): a ported chunked map over 500K elements took 39s, superlinear to ~700s at 2M. na-chunk-size equals pv-width and blocks are 32-aligned, so a block is exactly one trie leaf — pv-chunk-for hands it back in O(log n). Copy that leaf directly; fall back to per-index reads for the rare window that crosses a leaf boundary. Chunked map is now linear, ~133x faster at 500K (293ms) and within ~2.3x of the native seq loop, which makes a clojure-in-clojure seq tier viable. Corpus rows pin chunk-first window contents + chunk-rest boundaries against JVM; fixed a stale 'always false' chunked-seq? label. --- host/chez/java/natives-array.ss | 17 ++++++++++++++++- test/chez/corpus.edn | 7 ++++++- 2 files changed, 22 insertions(+), 2 deletions(-) diff --git a/host/chez/java/natives-array.ss b/host/chez/java/natives-array.ss index 403639a..68c14b8 100644 --- a/host/chez/java/natives-array.ss +++ b/host/chez/java/natives-array.ss @@ -109,9 +109,24 @@ (let* ((v (cseq-cvec s)) (i (cseq-ci s))) (cons v (fxmin (fx+ i na-chunk-size) (pvec-count v)))))) (define (na-chunked-seq? x) (and (na-vblock x) #t)) +;; Copy the block [i, end) straight out of the pvec trie's 32-element leaf node +;; (pv-chunk-for is O(log n)). na-chunk-size == pv-width and blocks are 32-aligned, +;; so a block is exactly one leaf; the rare non-aligned window crossing a leaf +;; boundary falls back to per-index reads. Flattening the whole backing vector +;; per block (pvec-v) made chunk-first O(n), so walking a vector chunk-by-chunk +;; was O(n^2). (define (na-chunk-first s) (let ((vb (na-vblock s))) - (if vb (make-pvec (vec-copy-range (pvec-v (car vb)) (cseq-ci s) (cdr vb))) + (if vb + (let* ((pv (car vb)) (i (cseq-ci s)) (end (cdr vb)) (len (fx- end i)) + (node (pv-chunk-for pv i)) (off (fxand i pv-mask))) + (if (fx<=? (fx+ off len) (vector-length node)) + (make-pvec (vec-copy-range node off (fx+ off len))) + (let ((out (make-vector len))) + (let loop ((j 0)) + (if (fx Date: Sun, 28 Jun 2026 03:22:47 -0400 Subject: [PATCH 3/7] conformance: audit + pin seq semantics (laziness, eagerness, chunking, type) A 62-case jolt-vs-JVM probe across seq type identity, chunking granularity, eagerness, and realization timing. Findings: the whole producer family is lazy at construction (no eager bugs remain), and the 26 divergences fall into two classes that diverge by representation, not value. Lock in the laziness contract as certified corpus rows: construction=0 for keep/keep-indexed/map-indexed/distinct/partition-by/partition-all/ interpose/interleave/take-nth/reductions/tree-seq/replace, sequence realizes 1, next realizes 2, rest realizes 1. Pin the two accepted divergence classes (allowlisted, gate-guarded): - seq-type-model: jolt reifies seqs as PersistentList/LazySeq vs JVM's Cons/Iterate/LongRange/Repeat/Cycle/ChunkedSeq/StringSeq/KeySeq/RSeq/ ArraySeq/SubVector (jolt-aei7) - chunking-model: unchunked, realizes one where JVM realizes a 32-chunk; mapcat/dedupe fully lazy at construction (jolt-mm6v) known-divergences.edn gains both categories; SPEC.md documents the seq semantics contract. Data/doc only, no re-mint. certify 0 new / 0 stale. --- test/chez/corpus.edn | 37 ++++++++++++++++++++++++++ test/conformance/SPEC.md | 35 ++++++++++++++++++++++++ test/conformance/known-divergences.edn | 24 +++++++++++++++-- 3 files changed, 94 insertions(+), 2 deletions(-) diff --git a/test/chez/corpus.edn b/test/chez/corpus.edn index aca2fc1..0e74fd2 100644 --- a/test/chez/corpus.edn +++ b/test/chez/corpus.edn @@ -801,6 +801,21 @@ {:suite "lazy / realization order & count" :label "drop+first realizes through the index" :expected "3" :actual "(let [a (atom 0)] (first (drop 2 (map (fn [x] (swap! a inc) x) (iterate inc 0)))) @a)"} {:suite "lazy / realization is memoized" :label "first twice realizes once" :expected "1" :actual "(let [a (atom 0) s (map (fn [x] (swap! a inc) x) (iterate inc 0))] (first s) (first s) @a)"} {:suite "lazy / realization is memoized" :label "wider take extends, does not re-realize" :expected "4" :actual "(let [a (atom 0) s (map (fn [x] (swap! a inc) x) (iterate inc 0))] (doall (take 2 s)) (doall (take 4 s)) @a)"} + {:suite "lazy / family is lazy at construction (no side effect)" :label "keep" :expected "0" :actual "(let [a (atom 0)] (keep (fn [x] (swap! a inc) x) (range 5)) @a)"} + {:suite "lazy / family is lazy at construction (no side effect)" :label "keep-indexed" :expected "0" :actual "(let [a (atom 0)] (keep-indexed (fn [i x] (swap! a inc) x) (range 5)) @a)"} + {:suite "lazy / family is lazy at construction (no side effect)" :label "map-indexed" :expected "0" :actual "(let [a (atom 0)] (map-indexed (fn [i x] (swap! a inc) x) (range 5)) @a)"} + {:suite "lazy / family is lazy at construction (no side effect)" :label "distinct" :expected "0" :actual "(let [a (atom 0)] (distinct (map (fn [x] (swap! a inc) x) (range 5))) @a)"} + {:suite "lazy / family is lazy at construction (no side effect)" :label "partition-by" :expected "0" :actual "(let [a (atom 0)] (partition-by (fn [x] (swap! a inc) x) (range 5)) @a)"} + {:suite "lazy / family is lazy at construction (no side effect)" :label "partition-all" :expected "0" :actual "(let [a (atom 0)] (partition-all 2 (map (fn [x] (swap! a inc) x) (range 5))) @a)"} + {:suite "lazy / family is lazy at construction (no side effect)" :label "interpose" :expected "0" :actual "(let [a (atom 0)] (interpose 0 (map (fn [x] (swap! a inc) x) (range 5))) @a)"} + {:suite "lazy / family is lazy at construction (no side effect)" :label "interleave" :expected "0" :actual "(let [a (atom 0)] (interleave (map (fn [x] (swap! a inc) x) (range 5)) (range 5)) @a)"} + {:suite "lazy / family is lazy at construction (no side effect)" :label "take-nth" :expected "0" :actual "(let [a (atom 0)] (take-nth 2 (map (fn [x] (swap! a inc) x) (range 5))) @a)"} + {:suite "lazy / family is lazy at construction (no side effect)" :label "reductions" :expected "0" :actual "(let [a (atom 0)] (reductions + (map (fn [x] (swap! a inc) x) (range 5))) @a)"} + {:suite "lazy / family is lazy at construction (no side effect)" :label "tree-seq" :expected "0" :actual "(let [a (atom 0)] (tree-seq (fn [x] (swap! a inc) false) identity [1 [2]]) @a)"} + {:suite "lazy / family is lazy at construction (no side effect)" :label "replace over a seq" :expected "0" :actual "(let [a (atom 0)] (replace {} (map (fn [x] (swap! a inc) x) (range 5))) @a)"} + {:suite "lazy / realization timing" :label "sequence realizes the first element" :expected "1" :actual "(let [a (atom 0)] (sequence (map (fn [x] (swap! a inc) x)) (range 5)) @a)"} + {:suite "lazy / realization timing" :label "next realizes head + one lookahead" :expected "2" :actual "(let [a (atom 0) s (map (fn [x] (swap! a inc) x) (iterate inc 0))] (next s) @a)"} + {:suite "lazy / realization timing" :label "rest realizes only the head" :expected "1" :actual "(let [a (atom 0) s (map (fn [x] (swap! a inc) x) (iterate inc 0))] (rest s) @a)"} {:suite "list / construct & predicate" :label "list" :expected "[1 2 3]" :actual "(list 1 2 3)"} {:suite "list / construct & predicate" :label "empty list" :expected "[]" :actual "(list)"} {:suite "list / construct & predicate" :label "quoted list" :expected "[1 2 3]" :actual "(quote (1 2 3))"} @@ -2714,6 +2729,28 @@ {:suite "chunked-seq / over a vector" :label "chunked-seq? false for a list seq" :expected "false" :actual "(chunked-seq? (seq (list 1 2 3)))"} {:suite "chunked-seq / over a vector" :label "chunk-first contents + chunk-rest boundary" :expected "[32 0 31 32]" :actual "(let [s (seq (vec (range 50))) c (chunk-first s)] [(count c) (nth c 0) (nth c 31) (first (chunk-rest s))])"} {:suite "chunked-seq / over a vector" :label "chunk-first window past the first block" :expected "[32 33 34 35 36 37 38 39]" :actual "(vec (chunk-first (chunk-rest (seq (vec (range 40))))))"} + ;; --- seq-type-model divergences (allowlisted): jolt models every seq as + ;; PersistentList (eager) or LazySeq (deferred); JVM reifies a specialized class + ;; per producer. Values + laziness are correct, only (class …) differs. jolt-aei7. + {:suite "seq-type-model / specialized seq classes collapse" :label "cons over a vector" :expected "clojure.lang.PersistentList" :actual "(class (cons 1 [2 3]))"} + {:suite "seq-type-model / specialized seq classes collapse" :label "iterate" :expected "clojure.lang.PersistentList" :actual "(class (iterate inc 0))"} + {:suite "seq-type-model / specialized seq classes collapse" :label "range" :expected "clojure.lang.PersistentList" :actual "(class (range 5))"} + {:suite "seq-type-model / specialized seq classes collapse" :label "repeat" :expected "clojure.lang.LazySeq" :actual "(class (repeat 3 :x))"} + {:suite "seq-type-model / specialized seq classes collapse" :label "cycle" :expected "clojure.lang.LazySeq" :actual "(class (cycle [1 2]))"} + {:suite "seq-type-model / specialized seq classes collapse" :label "vector seq" :expected "clojure.lang.PersistentList" :actual "(class (seq [1 2 3]))"} + {:suite "seq-type-model / specialized seq classes collapse" :label "string seq" :expected "clojure.lang.PersistentList" :actual "(class (seq \"abc\"))"} + {:suite "seq-type-model / specialized seq classes collapse" :label "keys" :expected "clojure.lang.PersistentList" :actual "(class (keys {:a 1 :b 2}))"} + {:suite "seq-type-model / specialized seq classes collapse" :label "rseq" :expected "clojure.lang.PersistentList" :actual "(class (rseq [1 2 3]))"} + {:suite "seq-type-model / specialized seq classes collapse" :label "sort" :expected "clojure.lang.PersistentList" :actual "(class (sort [3 1 2]))"} + {:suite "seq-type-model / specialized seq classes collapse" :label "subvec" :expected "clojure.lang.PersistentVector" :actual "(class (subvec [1 2 3] 1))"} + {:suite "seq-type-model / specialized seq classes collapse" :label "drop over a vector" :expected "clojure.lang.LazySeq" :actual "(class (drop 1 [1 2 3]))"} + ;; --- chunking-model divergences (allowlisted): jolt is unchunked, so forcing + ;; one element realizes 1 (JVM realizes a 32-element chunk), and mapcat/dedupe + ;; realize 0 at construction (JVM forces the first chunk). jolt-mm6v. + {:suite "chunking-model / unchunked realization granularity" :label "first over a vector realizes one, not a chunk" :expected "1" :actual "(let [a (atom 0)] (first (map (fn [x] (swap! a inc) x) (vec (range 100)))) @a)"} + {:suite "chunking-model / unchunked realization granularity" :label "nth 0 over a vector realizes one" :expected "1" :actual "(let [a (atom 0)] (nth (map (fn [x] (swap! a inc) x) (vec (range 100))) 0) @a)"} + {:suite "chunking-model / unchunked realization granularity" :label "mapcat is fully lazy at construction" :expected "0" :actual "(let [a (atom 0)] (mapcat (fn [x] (swap! a inc) [x]) (range 5)) @a)"} + {:suite "chunking-model / unchunked realization granularity" :label "dedupe is fully lazy at construction" :expected "0" :actual "(let [a (atom 0)] (dedupe (map (fn [x] (swap! a inc) x) (range 5))) @a)"} {:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "class number" :expected "java.lang.Long" :actual "(class 1)"} {:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "class string" :expected "java.lang.String" :actual "(class \"s\")"} {:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "class keyword" :expected "clojure.lang.Keyword" :actual "(class :k)"} diff --git a/test/conformance/SPEC.md b/test/conformance/SPEC.md index 844a2ae..d8c58a4 100644 --- a/test/conformance/SPEC.md +++ b/test/conformance/SPEC.md @@ -84,6 +84,41 @@ implements. Current profile (≈2735 portable, ≈167 non-portable): | `:impl/representation` | representation detail (e.g. syntax-quote yields a `list?`, not a `Cons`) | | `:bug` | a *known defect* (tracked bead) — not a host difference | +## Seq semantics + +Values alone don't pin laziness — an eager `map` and a lazy `map` return the same +elements. The spec certifies seq *semantics* by reducing them to values with a +side-effect counter, so the corpus catches a laziness regression the value +comparison would miss. + +**Laziness (certified — jolt matches JVM).** The whole producer family +(`map`/`filter`/`remove`/`take`/`drop`/`concat`/`take-while`/`drop-while`/`mapcat`/ +`partition`/`partition-all`/`partition-by`/`keep`/`keep-indexed`/`map-indexed`/ +`distinct`/`interpose`/`interleave`/`take-nth`/`reductions`/`tree-seq`/`replace`) +is lazy at construction: building over a side-effecting source realizes **zero** +elements (`lazy / family is lazy at construction`). Realization order is +left-to-right, `take`/`nth`/`drop` realize exactly as far as demanded, a lazy seq +memoizes (realize-once across walks), and `next` realizes head + one lookahead +while `rest` realizes only the head (`lazy / realization order & count`, +`lazy / realization is memoized`, `lazy / realization timing`). A lazy result is +`clojure.lang.LazySeq`. + +**Accepted divergences.** jolt is a simpler, finer-grained superset of JVM seq +behavior; two classes diverge by representation, never by value, and are +allowlisted in `known-divergences.edn`: + +- **`:seq-type-model`** (`seq-type-model / …` suite, jolt-aei7) — jolt reifies + every seq as `PersistentList` (eager) or `LazySeq` (deferred). JVM has a + specialized class per producer (`Cons`, `Iterate`, `LongRange`, `Repeat`, + `Cycle`, `PersistentVector$ChunkedSeq`, `StringSeq`, `KeySeq`/`ValSeq`, `RSeq`, + `ArraySeq`, `SubVector`), so `(class …)` differs. `instance? + clojure.lang.ISeq/Sequential` and all values/laziness are correct. +- **`:chunking-model`** (`chunking-model / …` suite, jolt-mm6v) — jolt seqs are + unchunked: forcing one element realizes one, where JVM realizes a ~32-element + chunk; `mapcat`/`dedupe` realize 0 at construction where JVM forces the first + chunk. Strictly finer-grained laziness, decided after the chunk fast path + (jolt-j9dz) was made O(n). + ## Hosting jolt on a new runtime 1. Implement the reader + analyzer + a backend for your runtime (see the Chez port diff --git a/test/conformance/known-divergences.edn b/test/conformance/known-divergences.edn index 7ea0e7e..2940b78 100644 --- a/test/conformance/known-divergences.edn +++ b/test/conformance/known-divergences.edn @@ -12,7 +12,11 @@ :strictness "jolt is intentionally stricter: throws on odd assoc! args / defn with no param vector", :impl-detail - "representation detail: syntax-quote yields a list? (JVM yields a Cons)"}, + "representation detail: syntax-quote yields a list? (JVM yields a Cons)", + :seq-type-model + "jolt models every seq as PersistentList (eager) or LazySeq (deferred); JVM reifies a specialized class per producer (Cons/Iterate/LongRange/Repeat/Cycle/ChunkedSeq/StringSeq/KeySeq/RSeq/ArraySeq/SubVector). Values and laziness are correct, only (class …) differs. jolt-aei7", + :chunking-model + "jolt seqs are unchunked: forcing one element realizes one (JVM realizes a ~32-element chunk), and mapcat/dedupe realize 0 at construction where JVM forces the first chunk — jolt is a finer-grained lazy superset. jolt-mm6v"}, :entries [{:suite "forms / fn", :label "no param vector", @@ -34,4 +38,20 @@ :category :host-model} {:suite "untested / chunk family (eager equivalents) + cat", :label "chunk round-trip", - :category :host-model}]} + :category :host-model} + {:suite "seq-type-model / specialized seq classes collapse", :label "cons over a vector", :category :seq-type-model} + {:suite "seq-type-model / specialized seq classes collapse", :label "iterate", :category :seq-type-model} + {:suite "seq-type-model / specialized seq classes collapse", :label "range", :category :seq-type-model} + {:suite "seq-type-model / specialized seq classes collapse", :label "repeat", :category :seq-type-model} + {:suite "seq-type-model / specialized seq classes collapse", :label "cycle", :category :seq-type-model} + {:suite "seq-type-model / specialized seq classes collapse", :label "vector seq", :category :seq-type-model} + {:suite "seq-type-model / specialized seq classes collapse", :label "string seq", :category :seq-type-model} + {:suite "seq-type-model / specialized seq classes collapse", :label "keys", :category :seq-type-model} + {:suite "seq-type-model / specialized seq classes collapse", :label "rseq", :category :seq-type-model} + {:suite "seq-type-model / specialized seq classes collapse", :label "sort", :category :seq-type-model} + {:suite "seq-type-model / specialized seq classes collapse", :label "subvec", :category :seq-type-model} + {:suite "seq-type-model / specialized seq classes collapse", :label "drop over a vector", :category :seq-type-model} + {:suite "chunking-model / unchunked realization granularity", :label "first over a vector realizes one, not a chunk", :category :chunking-model} + {:suite "chunking-model / unchunked realization granularity", :label "nth 0 over a vector realizes one", :category :chunking-model} + {:suite "chunking-model / unchunked realization granularity", :label "mapcat is fully lazy at construction", :category :chunking-model} + {:suite "chunking-model / unchunked realization granularity", :label "dedupe is fully lazy at construction", :category :chunking-model}]} From 4a72897dfdaa7dc3260af180fb5af2c447cccfec Mon Sep 17 00:00:00 2001 From: Yogthos Date: Sun, 28 Jun 2026 10:28:10 -0400 Subject: [PATCH 4/7] conformance: document narrow-int unification (byte/short/int -> Long) jolt unifies every integer as one exact-integer type, so (byte/short/int n) report Long not Byte/Short/Integer and instance? Byte is false. Confirmed substrate-inherent: (byte 5) is a Chez immediate identical? to 5 (nothing to tag, numbers carry no metadata), and arithmetic compiles to a raw Chez + that a boxed narrow type would crash. Value/arithmetic/equality are correct. Certify the value-correctness (= to plain int, arithmetic promotes, is a Number) and pin the class/instance? divergence under a new :integer-box-model category. Data/doc only. --- test/chez/corpus.edn | 15 +++++++++++++++ test/conformance/SPEC.md | 13 +++++++++++++ test/conformance/known-divergences.edn | 11 +++++++++-- 3 files changed, 37 insertions(+), 2 deletions(-) diff --git a/test/chez/corpus.edn b/test/chez/corpus.edn index 0e74fd2..e178fe0 100644 --- a/test/chez/corpus.edn +++ b/test/chez/corpus.edn @@ -2751,6 +2751,21 @@ {:suite "chunking-model / unchunked realization granularity" :label "nth 0 over a vector realizes one" :expected "1" :actual "(let [a (atom 0)] (nth (map (fn [x] (swap! a inc) x) (vec (range 100))) 0) @a)"} {:suite "chunking-model / unchunked realization granularity" :label "mapcat is fully lazy at construction" :expected "0" :actual "(let [a (atom 0)] (mapcat (fn [x] (swap! a inc) [x]) (range 5)) @a)"} {:suite "chunking-model / unchunked realization granularity" :label "dedupe is fully lazy at construction" :expected "0" :actual "(let [a (atom 0)] (dedupe (map (fn [x] (swap! a inc) x) (range 5))) @a)"} + ;; --- integer-box-model: narrow int values behave as integers (certified) --- + ;; jolt unifies every integer as one exact-integer type, so (byte/short/int n) + ;; produce value-correct integers — only the reified class differs (below). + {:suite "integer-box-model / narrow ints behave as integers" :label "byte = plain integer by value" :expected "true" :actual "(= (byte 5) 5)"} + {:suite "integer-box-model / narrow ints behave as integers" :label "byte arithmetic promotes" :expected "6" :actual "(+ (byte 5) 1)"} + {:suite "integer-box-model / narrow ints behave as integers" :label "byte is a Number" :expected "true" :actual "(instance? Number (byte 5))"} + ;; --- integer-box-model divergences (allowlisted): no narrow box types. A Chez + ;; fixnum is an immediate identical to the plain integer (cannot be tagged), so + ;; (byte/short/int n) report Long, not Byte/Short/Integer. Value is correct. + ;; jolt-k9sw (accepted divergence). + {:suite "integer-box-model / narrow int class collapses to Long" :label "byte class" :expected "java.lang.Long" :actual "(class (byte 5))"} + {:suite "integer-box-model / narrow int class collapses to Long" :label "short class" :expected "java.lang.Long" :actual "(class (short 5))"} + {:suite "integer-box-model / narrow int class collapses to Long" :label "int class" :expected "java.lang.Long" :actual "(class (int 5))"} + {:suite "integer-box-model / narrow int class collapses to Long" :label "instance? Byte is false" :expected "false" :actual "(instance? Byte (byte 5))"} + {:suite "integer-box-model / narrow int class collapses to Long" :label "instance? Long is true" :expected "true" :actual "(instance? Long (byte 5))"} {:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "class number" :expected "java.lang.Long" :actual "(class 1)"} {:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "class string" :expected "java.lang.String" :actual "(class \"s\")"} {:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "class keyword" :expected "clojure.lang.Keyword" :actual "(class :k)"} diff --git a/test/conformance/SPEC.md b/test/conformance/SPEC.md index d8c58a4..bf9cef1 100644 --- a/test/conformance/SPEC.md +++ b/test/conformance/SPEC.md @@ -119,6 +119,19 @@ allowlisted in `known-divergences.edn`: chunk. Strictly finer-grained laziness, decided after the chunk fast path (jolt-j9dz) was made O(n). +## Narrow integer types + +jolt unifies every integer as one exact-integer type (`:integer-box-model`, +jolt-k9sw). `(byte n)`/`(short n)`/`(int n)` produce value-correct integers — +arithmetic, `=`, and `hash` behave exactly as the JVM — but report `Long`, not +`Byte`/`Short`/`Integer`, so `(class (byte 5))` and `(instance? Byte (byte 5))` +diverge. This is substrate-inherent: a Chez fixnum is an immediate `identical?` +to the plain integer (nothing to tag, and numbers carry no metadata), so the only +faithful representation is a boxed type — which would crash raw compiled `(+ …)` +(arithmetic emits a bare Chez `+`) or force every `+`/`-`/`*` through an +unwrapping dispatcher, de-optimizing all arithmetic. Same shape as the accepted +BigInt-vs-Long unification. + ## Hosting jolt on a new runtime 1. Implement the reader + analyzer + a backend for your runtime (see the Chez port diff --git a/test/conformance/known-divergences.edn b/test/conformance/known-divergences.edn index 2940b78..a49ea24 100644 --- a/test/conformance/known-divergences.edn +++ b/test/conformance/known-divergences.edn @@ -16,7 +16,9 @@ :seq-type-model "jolt models every seq as PersistentList (eager) or LazySeq (deferred); JVM reifies a specialized class per producer (Cons/Iterate/LongRange/Repeat/Cycle/ChunkedSeq/StringSeq/KeySeq/RSeq/ArraySeq/SubVector). Values and laziness are correct, only (class …) differs. jolt-aei7", :chunking-model - "jolt seqs are unchunked: forcing one element realizes one (JVM realizes a ~32-element chunk), and mapcat/dedupe realize 0 at construction where JVM forces the first chunk — jolt is a finer-grained lazy superset. jolt-mm6v"}, + "jolt seqs are unchunked: forcing one element realizes one (JVM realizes a ~32-element chunk), and mapcat/dedupe realize 0 at construction where JVM forces the first chunk — jolt is a finer-grained lazy superset. jolt-mm6v", + :integer-box-model + "jolt unifies every integer as one exact-integer type. A Chez fixnum is an immediate identical to the plain integer (no distinct identity to tag, no metadata on numbers), so (byte/short/int n) report Long, not Byte/Short/Integer. Value/arithmetic/equality are correct; a faithful narrow box would crash raw compiled (+ …) or de-optimize all arithmetic. jolt-k9sw"}, :entries [{:suite "forms / fn", :label "no param vector", @@ -54,4 +56,9 @@ {:suite "chunking-model / unchunked realization granularity", :label "first over a vector realizes one, not a chunk", :category :chunking-model} {:suite "chunking-model / unchunked realization granularity", :label "nth 0 over a vector realizes one", :category :chunking-model} {:suite "chunking-model / unchunked realization granularity", :label "mapcat is fully lazy at construction", :category :chunking-model} - {:suite "chunking-model / unchunked realization granularity", :label "dedupe is fully lazy at construction", :category :chunking-model}]} + {:suite "chunking-model / unchunked realization granularity", :label "dedupe is fully lazy at construction", :category :chunking-model} + {:suite "integer-box-model / narrow int class collapses to Long", :label "byte class", :category :integer-box-model} + {:suite "integer-box-model / narrow int class collapses to Long", :label "short class", :category :integer-box-model} + {:suite "integer-box-model / narrow int class collapses to Long", :label "int class", :category :integer-box-model} + {:suite "integer-box-model / narrow int class collapses to Long", :label "instance? Byte is false", :category :integer-box-model} + {:suite "integer-box-model / narrow int class collapses to Long", :label "instance? Long is true", :category :integer-box-model}]} From b5ea06c5c26e0d96e03155ed6ba09a5a41e3d820 Mon Sep 17 00:00:00 2001 From: Yogthos Date: Sun, 28 Jun 2026 10:37:59 -0400 Subject: [PATCH 5/7] clojure.test: assert-expr / do-report / report extension points jolt's `is` was a fixed macro with no assert-expr multimethod, and the runner bypassed the report multimethod, so libraries couldn't register custom assertions or custom report types (e.g. test.check's ::trial/::shrunk). Add assert-expr (2-arg [msg form], dispatch on the form's first symbol / :default / :always-fail), do-report routing through report, and report :pass/:fail/:error methods that feed the counters. `is` dispatches to an explicitly-registered assert-expr method before its inline path, so thrown?/ thrown-with-msg?/= and every built-in form stay byte-identical. Runtime stdlib only, no re-mint. test/chez/clojure-test.clj self-checks the extension points + full is/are/testing/thrown?/use-fixtures surface; smoke gate runs it. --- host/chez/smoke.sh | 12 ++++++++++ stdlib/clojure/test.clj | 43 ++++++++++++++++++++++++++++++++++ test/chez/clojure-test.clj | 47 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 102 insertions(+) create mode 100644 test/chez/clojure-test.clj diff --git a/host/chez/smoke.sh b/host/chez/smoke.sh index 11eacf4..25818ae 100755 --- a/host/chez/smoke.sh +++ b/host/chez/smoke.sh @@ -46,5 +46,17 @@ check '(== 3 3.0)' 'true' check_loc '(throw (ex-info "boom" {}))' ' at 1:' check_loc '(do (+ 1 1) (/ 1 0))' ' at 1:' +# clojure.test extension points (assert-expr / do-report / report) need separate +# top-level forms — assert-expr must register before `is` expands — so this is a +# multi-form `joltc run`, not an -e one-liner. The file self-checks its tallies. +ct_out="$(bin/joltc run test/chez/clojure-test.clj 2>/dev/null)" +if printf '%s' "$ct_out" | grep -q 'CLOJURE-TEST OK'; then + pass=$((pass + 1)) +else + echo " FAIL: clojure.test extension points" + echo " $(printf '%s' "$ct_out" | grep CLOJURE-TEST | tail -1)" + fails=$((fails + 1)) +fi + echo "cli smoke: $pass passed, $fails failed" [ "$fails" -eq 0 ] diff --git a/stdlib/clojure/test.clj b/stdlib/clojure/test.clj index 8968ebd..420da95 100644 --- a/stdlib/clojure/test.clj +++ b/stdlib/clojure/test.clj @@ -66,6 +66,42 @@ (defmulti report :type) (defmethod report :default [_m] nil) +;; do-report routes a {:type …} report map through the report multimethod — the +;; seam clojure.test assertions emit through. The built-in :pass/:fail/:error +;; methods feed jolt's counters; a library can add report types (test.check's +;; ::trial/::shrunk/::complete) and they dispatch here. +(defn- report-line [m] + (str (when (:message m) (str (:message m) + (when (or (:form m) (contains? m :expected) (contains? m :actual)) " "))) + (when (:form m) (pr-str (:form m))) + (when (contains? m :expected) (str " expected: " (pr-str (:expected m)))) + (when (contains? m :actual) (str " actual: " (pr-str (:actual m)))))) +(defmethod report :pass [_m] (inc-pass!)) +(defmethod report :fail [m] (fail! (report-line m))) +(defmethod report :error [m] (err! (report-line m))) +(defn do-report [m] (report m)) + +;; assert-expr is the macro-level extension point: `is` expands a form by calling +;; (assert-expr msg form), dispatched on the form's first symbol (or :default / +;; :always-fail). A library registers a custom assertion via +;; (defmethod assert-expr 'my-pred [msg form] ). +;; 2-arg [msg form] signature matches clojure.test. `is` routes here only for a +;; symbol with an explicitly registered method, so built-in forms are unaffected. +(defmulti assert-expr (fn [_msg form] + (cond (nil? form) :always-fail + (and (seq? form) (symbol? (first form))) (first form) + :else :default))) +(defmethod assert-expr :always-fail [msg form] + `(clojure.test/do-report {:type :fail :message ~msg :form '~form})) +(defmethod assert-expr :default [msg form] + `(try + (if ~form + (clojure.test/do-report {:type :pass}) + (clojure.test/do-report {:type :fail :message ~msg :form '~form})) + (catch Throwable e# + (clojure.test/do-report {:type :error :message ~msg :form '~form + :actual (clojure.test/err-text e#)})))) + ;; --- class matching for thrown? -------------------------------------------- (defn- last-seg [s] @@ -130,6 +166,13 @@ (clojure.test/inc-pass!) (clojure.test/fail! (str "expected throw of " ~klass " matching " ~re " but got " (clojure.core/class e#) ": " m#))))))) + ;; a library-registered custom assertion (the assert-expr extension point); + ;; only fires for a symbol with an explicitly registered method, so built-in + ;; predicate forms keep the inline path below. + (and (seq? form) (symbol? (first form)) + (contains? (methods clojure.test/assert-expr) (first form))) + (clojure.test/assert-expr msg form) + :else `(try (if ~form diff --git a/test/chez/clojure-test.clj b/test/chez/clojure-test.clj new file mode 100644 index 0000000..e222ae3 --- /dev/null +++ b/test/chez/clojure-test.clj @@ -0,0 +1,47 @@ +;; Self-checking regression for clojure.test: the assert-expr / do-report / report +;; extension points plus the built-in is/are/testing/thrown?/use-fixtures surface. +;; Run via bin/joltc; prints a single sentinel line the smoke gate greps for. +(ns clojure-test-selfcheck + (:require [clojure.test :as t :refer [deftest is are testing use-fixtures run-tests]])) + +;; a library-style custom assertion registered through the assert-expr seam +(defmethod t/assert-expr 'near? [msg form] + (let [[_ a b] form] + `(if (< (let [d# (- ~a ~b)] (if (neg? d#) (- d#) d#)) 0.01) + (clojure.test/do-report {:type :pass}) + (clojure.test/do-report {:type :fail :message ~msg :form '~form})))) + +;; a custom report type (how test.check surfaces trial/shrink progress) +(def trials (atom 0)) +(defmethod t/report ::trial [_m] (swap! trials inc)) + +(def setups (atom 0)) +(use-fixtures :each (fn [f] (swap! setups inc) (f))) + +(deftest builtins + (testing "equality + predicate" + (is (= 1 1)) + (is (vector? [1]))) + (are [x y] (= x y) + 2 (+ 1 1) + 6 (* 2 3)) + (is (thrown? clojure.lang.ExceptionInfo (throw (ex-info "x" {})))) + (is (thrown-with-msg? Exception #"bad" (throw (ex-info "bad" {})))) + (is (near? 1.0 1.005))) + +(deftest expected-fail + (is (= 1 2)) + (is (near? 1.0 5.0))) + +(run-tests) +(t/do-report {:type ::trial}) +(t/do-report {:type ::trial}) + +;; 7 pass (= + vector? + 2 are rows + thrown? + thrown-with-msg? + near?), +;; 2 fail (= 1 2, near? 1.0 5.0), 0 error, 2 fixture runs, 2 custom reports +(let [ok (and (= (t/n-pass) 7) (= (t/n-fail) 2) (= (t/n-error) 0) + (= @setups 2) (= @trials 2))] + (println (if ok + "CLOJURE-TEST OK" + (str "CLOJURE-TEST FAIL pass=" (t/n-pass) " fail=" (t/n-fail) + " error=" (t/n-error) " setups=" @setups " trials=" @trials)))) From f17b68ccfee2d69e67b5188d0f1aaa2be02a837f Mon Sep 17 00:00:00 2001 From: Yogthos Date: Sun, 28 Jun 2026 11:25:52 -0400 Subject: [PATCH 6/7] backend: emit bitwise ops as native ops (test.check PRNG ~2.4x) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Profiling the test.check distribution/large-sample slowness (jolt-i5if): the hot path is the SplitMix PRNG, dominated by 64-bit mix arithmetic, and the bitwise ops (bit-and/or/xor/not, shifts) were NOT in the backend native-ops table — so (bit-xor a b) compiled to a var-deref through the variadic overlay (__bit-xor) instead of a direct call, the way +/-/* already emit. Map bit-and/or/xor/not to the Chez bitwise-and/ior/xor/not primitives (inlined to native code; a non-integer operand now errors like the JVM instead of being silently truncated) and the shifts to a direct helper call. bit-and-not stays on its overlay — its only Scheme impl is 2-arg, so a value-position arity-3 use would mis-emit. mix-64 arithmetic 2.7x faster, raw split+rand-long 2.4x, gen/vector ~1.4x. The remaining gap is the bignum-vs-native-long floor (~20x, substrate) plus the generator machinery (deftype/fn dispatch, separate). Corpus rows added for value position, bit-not, apply, and a full-64-bit unsigned shift. --- host/chez/seed/image.ss | 262 +++++++++++++++--------------- host/chez/seed/prelude.ss | 6 +- jolt-core/jolt/backend_scheme.clj | 15 +- test/chez/corpus.edn | 5 + 4 files changed, 153 insertions(+), 135 deletions(-) diff --git a/host/chez/seed/image.ss b/host/chez/seed/image.ss index 47f2286..834a49d 100644 --- a/host/chez/seed/image.ss +++ b/host/chez/seed/image.ss @@ -1,279 +1,279 @@ (guard (e (#t #f)) - (def-var! "jolt.ir" "const" (letrec ((const (lambda (v) (let fnrec8239 ((v v)) (let* ((_o$8240 (keyword #f "op")) (_o$8241 (keyword #f "const")) (_o$8242 (keyword #f "val")) (_o$8243 v)) (jolt-hash-map _o$8240 _o$8241 _o$8242 _o$8243)))))) const))) + (def-var! "jolt.ir" "const" (letrec ((const (lambda (v) (let fnrec8274 ((v v)) (let* ((_o$8275 (keyword #f "op")) (_o$8276 (keyword #f "const")) (_o$8277 (keyword #f "val")) (_o$8278 v)) (jolt-hash-map _o$8275 _o$8276 _o$8277 _o$8278)))))) const))) (guard (e (#t #f)) - (def-var! "jolt.ir" "local" (letrec ((local (lambda (name) (let fnrec8244 ((name name)) (let* ((_o$8245 (keyword #f "op")) (_o$8246 (keyword #f "local")) (_o$8247 (keyword #f "name")) (_o$8248 name)) (jolt-hash-map _o$8245 _o$8246 _o$8247 _o$8248)))))) local))) + (def-var! "jolt.ir" "local" (letrec ((local (lambda (name) (let fnrec8279 ((name name)) (let* ((_o$8280 (keyword #f "op")) (_o$8281 (keyword #f "local")) (_o$8282 (keyword #f "name")) (_o$8283 name)) (jolt-hash-map _o$8280 _o$8281 _o$8282 _o$8283)))))) local))) (guard (e (#t #f)) - (def-var! "jolt.ir" "var-ref" (letrec ((var-ref (lambda (ns name) (let fnrec8249 ((ns ns) (name name)) (let* ((_o$8250 (keyword #f "op")) (_o$8251 (keyword #f "var")) (_o$8252 (keyword #f "ns")) (_o$8253 ns) (_o$8254 (keyword #f "name")) (_o$8255 name)) (jolt-hash-map _o$8250 _o$8251 _o$8252 _o$8253 _o$8254 _o$8255)))))) var-ref))) + (def-var! "jolt.ir" "var-ref" (letrec ((var-ref (lambda (ns name) (let fnrec8284 ((ns ns) (name name)) (let* ((_o$8285 (keyword #f "op")) (_o$8286 (keyword #f "var")) (_o$8287 (keyword #f "ns")) (_o$8288 ns) (_o$8289 (keyword #f "name")) (_o$8290 name)) (jolt-hash-map _o$8285 _o$8286 _o$8287 _o$8288 _o$8289 _o$8290)))))) var-ref))) (guard (e (#t #f)) - (def-var! "jolt.ir" "the-var" (letrec ((the-var (lambda (ns name) (let fnrec8256 ((ns ns) (name name)) (let* ((_o$8257 (keyword #f "op")) (_o$8258 (keyword #f "the-var")) (_o$8259 (keyword #f "ns")) (_o$8260 ns) (_o$8261 (keyword #f "name")) (_o$8262 name)) (jolt-hash-map _o$8257 _o$8258 _o$8259 _o$8260 _o$8261 _o$8262)))))) the-var))) + (def-var! "jolt.ir" "the-var" (letrec ((the-var (lambda (ns name) (let fnrec8291 ((ns ns) (name name)) (let* ((_o$8292 (keyword #f "op")) (_o$8293 (keyword #f "the-var")) (_o$8294 (keyword #f "ns")) (_o$8295 ns) (_o$8296 (keyword #f "name")) (_o$8297 name)) (jolt-hash-map _o$8292 _o$8293 _o$8294 _o$8295 _o$8296 _o$8297)))))) the-var))) (guard (e (#t #f)) - (def-var! "jolt.ir" "host-ref" (letrec ((host-ref (lambda (name) (let fnrec8263 ((name name)) (let* ((_o$8264 (keyword #f "op")) (_o$8265 (keyword #f "host")) (_o$8266 (keyword #f "name")) (_o$8267 name)) (jolt-hash-map _o$8264 _o$8265 _o$8266 _o$8267)))))) host-ref))) + (def-var! "jolt.ir" "host-ref" (letrec ((host-ref (lambda (name) (let fnrec8298 ((name name)) (let* ((_o$8299 (keyword #f "op")) (_o$8300 (keyword #f "host")) (_o$8301 (keyword #f "name")) (_o$8302 name)) (jolt-hash-map _o$8299 _o$8300 _o$8301 _o$8302)))))) host-ref))) (guard (e (#t #f)) - (def-var! "jolt.ir" "host-static" (letrec ((host-static (lambda (class member) (let fnrec8268 ((class class) (member member)) (let* ((_o$8269 (keyword #f "op")) (_o$8270 (keyword #f "host-static")) (_o$8271 (keyword #f "class")) (_o$8272 class) (_o$8273 (keyword #f "member")) (_o$8274 member)) (jolt-hash-map _o$8269 _o$8270 _o$8271 _o$8272 _o$8273 _o$8274)))))) host-static))) + (def-var! "jolt.ir" "host-static" (letrec ((host-static (lambda (class member) (let fnrec8303 ((class class) (member member)) (let* ((_o$8304 (keyword #f "op")) (_o$8305 (keyword #f "host-static")) (_o$8306 (keyword #f "class")) (_o$8307 class) (_o$8308 (keyword #f "member")) (_o$8309 member)) (jolt-hash-map _o$8304 _o$8305 _o$8306 _o$8307 _o$8308 _o$8309)))))) host-static))) (guard (e (#t #f)) - (def-var! "jolt.ir" "host-new" (letrec ((host-new (lambda (class args) (let fnrec8275 ((class class) (args args)) (let* ((_o$8276 (keyword #f "op")) (_o$8277 (keyword #f "host-new")) (_o$8278 (keyword #f "class")) (_o$8279 class) (_o$8280 (keyword #f "args")) (_o$8281 args)) (jolt-hash-map _o$8276 _o$8277 _o$8278 _o$8279 _o$8280 _o$8281)))))) host-new))) + (def-var! "jolt.ir" "host-new" (letrec ((host-new (lambda (class args) (let fnrec8310 ((class class) (args args)) (let* ((_o$8311 (keyword #f "op")) (_o$8312 (keyword #f "host-new")) (_o$8313 (keyword #f "class")) (_o$8314 class) (_o$8315 (keyword #f "args")) (_o$8316 args)) (jolt-hash-map _o$8311 _o$8312 _o$8313 _o$8314 _o$8315 _o$8316)))))) host-new))) (guard (e (#t #f)) - (def-var! "jolt.ir" "if-node" (letrec ((if-node (lambda (test then _else) (let fnrec8282 ((test test) (then then) (_else _else)) (let* ((_o$8283 (keyword #f "op")) (_o$8284 (keyword #f "if")) (_o$8285 (keyword #f "test")) (_o$8286 test) (_o$8287 (keyword #f "then")) (_o$8288 then) (_o$8289 (keyword #f "else")) (_o$8290 _else)) (jolt-hash-map _o$8283 _o$8284 _o$8285 _o$8286 _o$8287 _o$8288 _o$8289 _o$8290)))))) if-node))) + (def-var! "jolt.ir" "if-node" (letrec ((if-node (lambda (test then _else) (let fnrec8317 ((test test) (then then) (_else _else)) (let* ((_o$8318 (keyword #f "op")) (_o$8319 (keyword #f "if")) (_o$8320 (keyword #f "test")) (_o$8321 test) (_o$8322 (keyword #f "then")) (_o$8323 then) (_o$8324 (keyword #f "else")) (_o$8325 _else)) (jolt-hash-map _o$8318 _o$8319 _o$8320 _o$8321 _o$8322 _o$8323 _o$8324 _o$8325)))))) if-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "do-node" (letrec ((do-node (lambda (statements ret) (let fnrec8291 ((statements statements) (ret ret)) (let* ((_o$8292 (keyword #f "op")) (_o$8293 (keyword #f "do")) (_o$8294 (keyword #f "statements")) (_o$8295 statements) (_o$8296 (keyword #f "ret")) (_o$8297 ret)) (jolt-hash-map _o$8292 _o$8293 _o$8294 _o$8295 _o$8296 _o$8297)))))) do-node))) + (def-var! "jolt.ir" "do-node" (letrec ((do-node (lambda (statements ret) (let fnrec8326 ((statements statements) (ret ret)) (let* ((_o$8327 (keyword #f "op")) (_o$8328 (keyword #f "do")) (_o$8329 (keyword #f "statements")) (_o$8330 statements) (_o$8331 (keyword #f "ret")) (_o$8332 ret)) (jolt-hash-map _o$8327 _o$8328 _o$8329 _o$8330 _o$8331 _o$8332)))))) do-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "invoke" (letrec ((invoke (lambda (f args) (let fnrec8298 ((f f) (args args)) (let* ((_o$8299 (keyword #f "op")) (_o$8300 (keyword #f "invoke")) (_o$8301 (keyword #f "fn")) (_o$8302 f) (_o$8303 (keyword #f "args")) (_o$8304 args)) (jolt-hash-map _o$8299 _o$8300 _o$8301 _o$8302 _o$8303 _o$8304)))))) invoke))) + (def-var! "jolt.ir" "invoke" (letrec ((invoke (lambda (f args) (let fnrec8333 ((f f) (args args)) (let* ((_o$8334 (keyword #f "op")) (_o$8335 (keyword #f "invoke")) (_o$8336 (keyword #f "fn")) (_o$8337 f) (_o$8338 (keyword #f "args")) (_o$8339 args)) (jolt-hash-map _o$8334 _o$8335 _o$8336 _o$8337 _o$8338 _o$8339)))))) invoke))) (guard (e (#t #f)) - (def-var! "jolt.ir" "def-node" (letrec ((def-node (case-lambda ((ns name init) (let fnrec8305 ((ns ns) (name name) (init init)) (let* ((_o$8306 (keyword #f "op")) (_o$8307 (keyword #f "def")) (_o$8308 (keyword #f "ns")) (_o$8309 ns) (_o$8310 (keyword #f "name")) (_o$8311 name) (_o$8312 (keyword #f "init")) (_o$8313 init)) (jolt-hash-map _o$8306 _o$8307 _o$8308 _o$8309 _o$8310 _o$8311 _o$8312 _o$8313)))) ((ns name init meta) (let fnrec8314 ((ns ns) (name name) (init init) (meta meta)) (if (jolt-truthy? meta) (let* ((_o$8315 (keyword #f "op")) (_o$8316 (keyword #f "def")) (_o$8317 (keyword #f "ns")) (_o$8318 ns) (_o$8319 (keyword #f "name")) (_o$8320 name) (_o$8321 (keyword #f "init")) (_o$8322 init) (_o$8323 (keyword #f "meta")) (_o$8324 meta)) (jolt-hash-map _o$8315 _o$8316 _o$8317 _o$8318 _o$8319 _o$8320 _o$8321 _o$8322 _o$8323 _o$8324)) (let* ((_o$8325 (keyword #f "op")) (_o$8326 (keyword #f "def")) (_o$8327 (keyword #f "ns")) (_o$8328 ns) (_o$8329 (keyword #f "name")) (_o$8330 name) (_o$8331 (keyword #f "init")) (_o$8332 init)) (jolt-hash-map _o$8325 _o$8326 _o$8327 _o$8328 _o$8329 _o$8330 _o$8331 _o$8332)))))))) def-node))) + (def-var! "jolt.ir" "def-node" (letrec ((def-node (case-lambda ((ns name init) (let fnrec8340 ((ns ns) (name name) (init init)) (let* ((_o$8341 (keyword #f "op")) (_o$8342 (keyword #f "def")) (_o$8343 (keyword #f "ns")) (_o$8344 ns) (_o$8345 (keyword #f "name")) (_o$8346 name) (_o$8347 (keyword #f "init")) (_o$8348 init)) (jolt-hash-map _o$8341 _o$8342 _o$8343 _o$8344 _o$8345 _o$8346 _o$8347 _o$8348)))) ((ns name init meta) (let fnrec8349 ((ns ns) (name name) (init init) (meta meta)) (if (jolt-truthy? meta) (let* ((_o$8350 (keyword #f "op")) (_o$8351 (keyword #f "def")) (_o$8352 (keyword #f "ns")) (_o$8353 ns) (_o$8354 (keyword #f "name")) (_o$8355 name) (_o$8356 (keyword #f "init")) (_o$8357 init) (_o$8358 (keyword #f "meta")) (_o$8359 meta)) (jolt-hash-map _o$8350 _o$8351 _o$8352 _o$8353 _o$8354 _o$8355 _o$8356 _o$8357 _o$8358 _o$8359)) (let* ((_o$8360 (keyword #f "op")) (_o$8361 (keyword #f "def")) (_o$8362 (keyword #f "ns")) (_o$8363 ns) (_o$8364 (keyword #f "name")) (_o$8365 name) (_o$8366 (keyword #f "init")) (_o$8367 init)) (jolt-hash-map _o$8360 _o$8361 _o$8362 _o$8363 _o$8364 _o$8365 _o$8366 _o$8367)))))))) def-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "let-node" (letrec ((let-node (lambda (bindings body) (let fnrec8333 ((bindings bindings) (body body)) (let* ((_o$8334 (keyword #f "op")) (_o$8335 (keyword #f "let")) (_o$8336 (keyword #f "bindings")) (_o$8337 bindings) (_o$8338 (keyword #f "body")) (_o$8339 body)) (jolt-hash-map _o$8334 _o$8335 _o$8336 _o$8337 _o$8338 _o$8339)))))) let-node))) + (def-var! "jolt.ir" "let-node" (letrec ((let-node (lambda (bindings body) (let fnrec8368 ((bindings bindings) (body body)) (let* ((_o$8369 (keyword #f "op")) (_o$8370 (keyword #f "let")) (_o$8371 (keyword #f "bindings")) (_o$8372 bindings) (_o$8373 (keyword #f "body")) (_o$8374 body)) (jolt-hash-map _o$8369 _o$8370 _o$8371 _o$8372 _o$8373 _o$8374)))))) let-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "fn-node" (letrec ((fn-node (lambda (name arities) (let fnrec8340 ((name name) (arities arities)) (if (jolt-truthy? name) (let* ((_o$8341 (keyword #f "op")) (_o$8342 (keyword #f "fn")) (_o$8343 (keyword #f "name")) (_o$8344 name) (_o$8345 (keyword #f "arities")) (_o$8346 arities)) (jolt-hash-map _o$8341 _o$8342 _o$8343 _o$8344 _o$8345 _o$8346)) (let* ((_o$8347 (keyword #f "op")) (_o$8348 (keyword #f "fn")) (_o$8349 (keyword #f "arities")) (_o$8350 arities)) (jolt-hash-map _o$8347 _o$8348 _o$8349 _o$8350))))))) fn-node))) + (def-var! "jolt.ir" "fn-node" (letrec ((fn-node (lambda (name arities) (let fnrec8375 ((name name) (arities arities)) (if (jolt-truthy? name) (let* ((_o$8376 (keyword #f "op")) (_o$8377 (keyword #f "fn")) (_o$8378 (keyword #f "name")) (_o$8379 name) (_o$8380 (keyword #f "arities")) (_o$8381 arities)) (jolt-hash-map _o$8376 _o$8377 _o$8378 _o$8379 _o$8380 _o$8381)) (let* ((_o$8382 (keyword #f "op")) (_o$8383 (keyword #f "fn")) (_o$8384 (keyword #f "arities")) (_o$8385 arities)) (jolt-hash-map _o$8382 _o$8383 _o$8384 _o$8385))))))) fn-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "vector-node" (letrec ((vector-node (lambda (items) (let fnrec8351 ((items items)) (let* ((_o$8352 (keyword #f "op")) (_o$8353 (keyword #f "vector")) (_o$8354 (keyword #f "items")) (_o$8355 items)) (jolt-hash-map _o$8352 _o$8353 _o$8354 _o$8355)))))) vector-node))) + (def-var! "jolt.ir" "vector-node" (letrec ((vector-node (lambda (items) (let fnrec8386 ((items items)) (let* ((_o$8387 (keyword #f "op")) (_o$8388 (keyword #f "vector")) (_o$8389 (keyword #f "items")) (_o$8390 items)) (jolt-hash-map _o$8387 _o$8388 _o$8389 _o$8390)))))) vector-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "map-node" (letrec ((map-node (lambda (pairs) (let fnrec8356 ((pairs pairs)) (let* ((_o$8357 (keyword #f "op")) (_o$8358 (keyword #f "map")) (_o$8359 (keyword #f "pairs")) (_o$8360 pairs)) (jolt-hash-map _o$8357 _o$8358 _o$8359 _o$8360)))))) map-node))) + (def-var! "jolt.ir" "map-node" (letrec ((map-node (lambda (pairs) (let fnrec8391 ((pairs pairs)) (let* ((_o$8392 (keyword #f "op")) (_o$8393 (keyword #f "map")) (_o$8394 (keyword #f "pairs")) (_o$8395 pairs)) (jolt-hash-map _o$8392 _o$8393 _o$8394 _o$8395)))))) map-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "set-node" (letrec ((set-node (lambda (items) (let fnrec8361 ((items items)) (let* ((_o$8362 (keyword #f "op")) (_o$8363 (keyword #f "set")) (_o$8364 (keyword #f "items")) (_o$8365 items)) (jolt-hash-map _o$8362 _o$8363 _o$8364 _o$8365)))))) set-node))) + (def-var! "jolt.ir" "set-node" (letrec ((set-node (lambda (items) (let fnrec8396 ((items items)) (let* ((_o$8397 (keyword #f "op")) (_o$8398 (keyword #f "set")) (_o$8399 (keyword #f "items")) (_o$8400 items)) (jolt-hash-map _o$8397 _o$8398 _o$8399 _o$8400)))))) set-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "quote-node" (letrec ((quote-node (lambda (form) (let fnrec8366 ((form form)) (let* ((_o$8367 (keyword #f "op")) (_o$8368 (keyword #f "quote")) (_o$8369 (keyword #f "form")) (_o$8370 form)) (jolt-hash-map _o$8367 _o$8368 _o$8369 _o$8370)))))) quote-node))) + (def-var! "jolt.ir" "quote-node" (letrec ((quote-node (lambda (form) (let fnrec8401 ((form form)) (let* ((_o$8402 (keyword #f "op")) (_o$8403 (keyword #f "quote")) (_o$8404 (keyword #f "form")) (_o$8405 form)) (jolt-hash-map _o$8402 _o$8403 _o$8404 _o$8405)))))) quote-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "throw-node" (letrec ((throw-node (lambda (expr) (let fnrec8371 ((expr expr)) (let* ((_o$8372 (keyword #f "op")) (_o$8373 (keyword #f "throw")) (_o$8374 (keyword #f "expr")) (_o$8375 expr)) (jolt-hash-map _o$8372 _o$8373 _o$8374 _o$8375)))))) throw-node))) + (def-var! "jolt.ir" "throw-node" (letrec ((throw-node (lambda (expr) (let fnrec8406 ((expr expr)) (let* ((_o$8407 (keyword #f "op")) (_o$8408 (keyword #f "throw")) (_o$8409 (keyword #f "expr")) (_o$8410 expr)) (jolt-hash-map _o$8407 _o$8408 _o$8409 _o$8410)))))) throw-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "coerce-node" (letrec ((coerce-node (lambda (kind expr) (let fnrec8376 ((kind kind) (expr expr)) (let* ((_o$8377 (keyword #f "op")) (_o$8378 (keyword #f "coerce")) (_o$8379 (keyword #f "kind")) (_o$8380 kind) (_o$8381 (keyword #f "expr")) (_o$8382 expr)) (jolt-hash-map _o$8377 _o$8378 _o$8379 _o$8380 _o$8381 _o$8382)))))) coerce-node))) + (def-var! "jolt.ir" "coerce-node" (letrec ((coerce-node (lambda (kind expr) (let fnrec8411 ((kind kind) (expr expr)) (let* ((_o$8412 (keyword #f "op")) (_o$8413 (keyword #f "coerce")) (_o$8414 (keyword #f "kind")) (_o$8415 kind) (_o$8416 (keyword #f "expr")) (_o$8417 expr)) (jolt-hash-map _o$8412 _o$8413 _o$8414 _o$8415 _o$8416 _o$8417)))))) coerce-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "map-ir-children" (letrec ((map-ir-children (lambda (f node) (let fnrec8383 ((f f) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$8384 node) (_a$8385 (keyword #f "test")) (_a$8386 (jolt-invoke f (jolt-get node (keyword #f "test")))) (_a$8387 (keyword #f "then")) (_a$8388 (jolt-invoke f (jolt-get node (keyword #f "then")))) (_a$8389 (keyword #f "else")) (_a$8390 (jolt-invoke f (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$8384 _a$8385 _a$8386 _a$8387 _a$8388 _a$8389 _a$8390)) (if (jolt= op (keyword #f "do")) (let* ((_a$8391 node) (_a$8392 (keyword #f "statements")) (_a$8393 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "statements")))) (_a$8394 (keyword #f "ret")) (_a$8395 (jolt-invoke f (jolt-get node (keyword #f "ret"))))) (jolt-assoc _a$8391 _a$8392 _a$8393 _a$8394 _a$8395)) (if (jolt= op (keyword #f "throw")) (jolt-assoc node (keyword #f "expr") (jolt-invoke f (jolt-get node (keyword #f "expr")))) (if (jolt= op (keyword #f "coerce")) (jolt-assoc node (keyword #f "expr") (jolt-invoke f (jolt-get node (keyword #f "expr")))) (if (jolt= op (keyword #f "set-var")) (jolt-assoc node (keyword #f "val") (jolt-invoke f (jolt-get node (keyword #f "val")))) (if (jolt= op (keyword #f "set-field")) (let* ((_a$8396 node) (_a$8397 (keyword #f "obj")) (_a$8398 (jolt-invoke f (jolt-get node (keyword #f "obj")))) (_a$8399 (keyword #f "val")) (_a$8400 (jolt-invoke f (jolt-get node (keyword #f "val"))))) (jolt-assoc _a$8396 _a$8397 _a$8398 _a$8399 _a$8400)) (if (jolt= op (keyword #f "defmacro")) (jolt-assoc node (keyword #f "fn") (jolt-invoke f (jolt-get node (keyword #f "fn")))) (if (jolt= op (keyword #f "ffi-callable")) (jolt-assoc node (keyword #f "fn") (jolt-invoke f (jolt-get node (keyword #f "fn")))) (if (jolt= op (keyword #f "invoke")) (let* ((_a$8401 node) (_a$8402 (keyword #f "fn")) (_a$8403 (jolt-invoke f (jolt-get node (keyword #f "fn")))) (_a$8404 (keyword #f "args")) (_a$8405 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$8401 _a$8402 _a$8403 _a$8404 _a$8405)) (if (jolt= op (keyword #f "vector")) (jolt-assoc node (keyword #f "items") (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "items")))) (if (jolt= op (keyword #f "set")) (jolt-assoc node (keyword #f "items") (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "items")))) (if (jolt= op (keyword #f "map")) (jolt-assoc node (keyword #f "pairs") (let* ((_a$8409 (var-deref "clojure.core" "mapv")) (_a$8410 (lambda (pr) (let fnrec8406 ((pr pr)) (let* ((_o$8407 (jolt-invoke f (jolt-nth pr 0))) (_o$8408 (jolt-invoke f (jolt-nth pr 1)))) (jolt-vector _o$8407 _o$8408))))) (_a$8411 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$8409 _a$8410 _a$8411))) (if (jolt= op (keyword #f "let")) (let* ((_a$8418 node) (_a$8419 (keyword #f "bindings")) (_a$8420 (let* ((_a$8415 (var-deref "clojure.core" "mapv")) (_a$8416 (lambda (b) (let fnrec8412 ((b b)) (let* ((_o$8413 (jolt-nth b 0)) (_o$8414 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$8413 _o$8414))))) (_a$8417 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$8415 _a$8416 _a$8417))) (_a$8421 (keyword #f "body")) (_a$8422 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$8418 _a$8419 _a$8420 _a$8421 _a$8422)) (if (jolt= op (keyword #f "loop")) (let* ((_a$8429 node) (_a$8430 (keyword #f "bindings")) (_a$8431 (let* ((_a$8426 (var-deref "clojure.core" "mapv")) (_a$8427 (lambda (b) (let fnrec8423 ((b b)) (let* ((_o$8424 (jolt-nth b 0)) (_o$8425 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$8424 _o$8425))))) (_a$8428 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$8426 _a$8427 _a$8428))) (_a$8432 (keyword #f "body")) (_a$8433 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$8429 _a$8430 _a$8431 _a$8432 _a$8433)) (if (jolt= op (keyword #f "recur")) (jolt-assoc node (keyword #f "args") (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args")))) (if (jolt= op (keyword #f "fn")) (jolt-assoc node (keyword #f "arities") (let* ((_a$8435 (var-deref "clojure.core" "mapv")) (_a$8436 (lambda (a) (let fnrec8434 ((a a)) (jolt-assoc a (keyword #f "body") (jolt-invoke f (jolt-get a (keyword #f "body"))))))) (_a$8437 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$8435 _a$8436 _a$8437))) (if (jolt= op (keyword #f "def")) (let* ((n (jolt-assoc node (keyword #f "init") (jolt-invoke f (jolt-get node (keyword #f "init")))))) (if (jolt-truthy? (jolt-get node (keyword #f "meta-expr"))) (jolt-assoc n (keyword #f "meta-expr") (jolt-invoke f (jolt-get node (keyword #f "meta-expr")))) n)) (if (jolt= op (keyword #f "host-call")) (let* ((_a$8438 node) (_a$8439 (keyword #f "target")) (_a$8440 (jolt-invoke f (jolt-get node (keyword #f "target")))) (_a$8441 (keyword #f "args")) (_a$8442 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$8438 _a$8439 _a$8440 _a$8441 _a$8442)) (if (jolt= op (keyword #f "host-new")) (jolt-assoc node (keyword #f "args") (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args")))) (if (jolt= op (keyword #f "try")) (let* ((n (jolt-assoc node (keyword #f "body") (jolt-invoke f (jolt-get node (keyword #f "body"))))) (n (if (jolt-truthy? (jolt-get node (keyword #f "catch-body"))) (jolt-assoc n (keyword #f "catch-body") (jolt-invoke f (jolt-get node (keyword #f "catch-body")))) n)) (n (if (jolt-truthy? (jolt-get node (keyword #f "finally"))) (jolt-assoc n (keyword #f "finally") (jolt-invoke f (jolt-get node (keyword #f "finally")))) n))) n) (if (jolt-truthy? (keyword #f "else")) node jolt-nil)))))))))))))))))))))))))) map-ir-children))) + (def-var! "jolt.ir" "map-ir-children" (letrec ((map-ir-children (lambda (f node) (let fnrec8418 ((f f) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$8419 node) (_a$8420 (keyword #f "test")) (_a$8421 (jolt-invoke f (jolt-get node (keyword #f "test")))) (_a$8422 (keyword #f "then")) (_a$8423 (jolt-invoke f (jolt-get node (keyword #f "then")))) (_a$8424 (keyword #f "else")) (_a$8425 (jolt-invoke f (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$8419 _a$8420 _a$8421 _a$8422 _a$8423 _a$8424 _a$8425)) (if (jolt= op (keyword #f "do")) (let* ((_a$8426 node) (_a$8427 (keyword #f "statements")) (_a$8428 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "statements")))) (_a$8429 (keyword #f "ret")) (_a$8430 (jolt-invoke f (jolt-get node (keyword #f "ret"))))) (jolt-assoc _a$8426 _a$8427 _a$8428 _a$8429 _a$8430)) (if (jolt= op (keyword #f "throw")) (jolt-assoc node (keyword #f "expr") (jolt-invoke f (jolt-get node (keyword #f "expr")))) (if (jolt= op (keyword #f "coerce")) (jolt-assoc node (keyword #f "expr") (jolt-invoke f (jolt-get node (keyword #f "expr")))) (if (jolt= op (keyword #f "set-var")) (jolt-assoc node (keyword #f "val") (jolt-invoke f (jolt-get node (keyword #f "val")))) (if (jolt= op (keyword #f "set-field")) (let* ((_a$8431 node) (_a$8432 (keyword #f "obj")) (_a$8433 (jolt-invoke f (jolt-get node (keyword #f "obj")))) (_a$8434 (keyword #f "val")) (_a$8435 (jolt-invoke f (jolt-get node (keyword #f "val"))))) (jolt-assoc _a$8431 _a$8432 _a$8433 _a$8434 _a$8435)) (if (jolt= op (keyword #f "defmacro")) (jolt-assoc node (keyword #f "fn") (jolt-invoke f (jolt-get node (keyword #f "fn")))) (if (jolt= op (keyword #f "ffi-callable")) (jolt-assoc node (keyword #f "fn") (jolt-invoke f (jolt-get node (keyword #f "fn")))) (if (jolt= op (keyword #f "invoke")) (let* ((_a$8436 node) (_a$8437 (keyword #f "fn")) (_a$8438 (jolt-invoke f (jolt-get node (keyword #f "fn")))) (_a$8439 (keyword #f "args")) (_a$8440 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$8436 _a$8437 _a$8438 _a$8439 _a$8440)) (if (jolt= op (keyword #f "vector")) (jolt-assoc node (keyword #f "items") (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "items")))) (if (jolt= op (keyword #f "set")) (jolt-assoc node (keyword #f "items") (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "items")))) (if (jolt= op (keyword #f "map")) (jolt-assoc node (keyword #f "pairs") (let* ((_a$8444 (var-deref "clojure.core" "mapv")) (_a$8445 (lambda (pr) (let fnrec8441 ((pr pr)) (let* ((_o$8442 (jolt-invoke f (jolt-nth pr 0))) (_o$8443 (jolt-invoke f (jolt-nth pr 1)))) (jolt-vector _o$8442 _o$8443))))) (_a$8446 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$8444 _a$8445 _a$8446))) (if (jolt= op (keyword #f "let")) (let* ((_a$8453 node) (_a$8454 (keyword #f "bindings")) (_a$8455 (let* ((_a$8450 (var-deref "clojure.core" "mapv")) (_a$8451 (lambda (b) (let fnrec8447 ((b b)) (let* ((_o$8448 (jolt-nth b 0)) (_o$8449 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$8448 _o$8449))))) (_a$8452 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$8450 _a$8451 _a$8452))) (_a$8456 (keyword #f "body")) (_a$8457 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$8453 _a$8454 _a$8455 _a$8456 _a$8457)) (if (jolt= op (keyword #f "loop")) (let* ((_a$8464 node) (_a$8465 (keyword #f "bindings")) (_a$8466 (let* ((_a$8461 (var-deref "clojure.core" "mapv")) (_a$8462 (lambda (b) (let fnrec8458 ((b b)) (let* ((_o$8459 (jolt-nth b 0)) (_o$8460 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$8459 _o$8460))))) (_a$8463 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$8461 _a$8462 _a$8463))) (_a$8467 (keyword #f "body")) (_a$8468 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$8464 _a$8465 _a$8466 _a$8467 _a$8468)) (if (jolt= op (keyword #f "recur")) (jolt-assoc node (keyword #f "args") (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args")))) (if (jolt= op (keyword #f "fn")) (jolt-assoc node (keyword #f "arities") (let* ((_a$8470 (var-deref "clojure.core" "mapv")) (_a$8471 (lambda (a) (let fnrec8469 ((a a)) (jolt-assoc a (keyword #f "body") (jolt-invoke f (jolt-get a (keyword #f "body"))))))) (_a$8472 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$8470 _a$8471 _a$8472))) (if (jolt= op (keyword #f "def")) (let* ((n (jolt-assoc node (keyword #f "init") (jolt-invoke f (jolt-get node (keyword #f "init")))))) (if (jolt-truthy? (jolt-get node (keyword #f "meta-expr"))) (jolt-assoc n (keyword #f "meta-expr") (jolt-invoke f (jolt-get node (keyword #f "meta-expr")))) n)) (if (jolt= op (keyword #f "host-call")) (let* ((_a$8473 node) (_a$8474 (keyword #f "target")) (_a$8475 (jolt-invoke f (jolt-get node (keyword #f "target")))) (_a$8476 (keyword #f "args")) (_a$8477 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$8473 _a$8474 _a$8475 _a$8476 _a$8477)) (if (jolt= op (keyword #f "host-new")) (jolt-assoc node (keyword #f "args") (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args")))) (if (jolt= op (keyword #f "try")) (let* ((n (jolt-assoc node (keyword #f "body") (jolt-invoke f (jolt-get node (keyword #f "body"))))) (n (if (jolt-truthy? (jolt-get node (keyword #f "catch-body"))) (jolt-assoc n (keyword #f "catch-body") (jolt-invoke f (jolt-get node (keyword #f "catch-body")))) n)) (n (if (jolt-truthy? (jolt-get node (keyword #f "finally"))) (jolt-assoc n (keyword #f "finally") (jolt-invoke f (jolt-get node (keyword #f "finally")))) n))) n) (if (jolt-truthy? (keyword #f "else")) node jolt-nil)))))))))))))))))))))))))) map-ir-children))) (guard (e (#t #f)) - (def-var! "jolt.ir" "reduce-ir-children" (letrec ((reduce-ir-children (lambda (f acc node) (let fnrec8443 ((f f) (acc acc) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$8447 f) (_a$8448 (let* ((_a$8444 f) (_a$8445 (jolt-invoke f acc (jolt-get node (keyword #f "test")))) (_a$8446 (jolt-get node (keyword #f "then")))) (jolt-invoke _a$8444 _a$8445 _a$8446))) (_a$8449 (jolt-get node (keyword #f "else")))) (jolt-invoke _a$8447 _a$8448 _a$8449)) (if (jolt= op (keyword #f "do")) (let* ((_a$8450 f) (_a$8451 (jolt-reduce f acc (jolt-get node (keyword #f "statements")))) (_a$8452 (jolt-get node (keyword #f "ret")))) (jolt-invoke _a$8450 _a$8451 _a$8452)) (if (jolt= op (keyword #f "throw")) (jolt-invoke f acc (jolt-get node (keyword #f "expr"))) (if (jolt= op (keyword #f "coerce")) (jolt-invoke f acc (jolt-get node (keyword #f "expr"))) (if (jolt= op (keyword #f "set-var")) (jolt-invoke f acc (jolt-get node (keyword #f "val"))) (if (jolt= op (keyword #f "set-field")) (let* ((_a$8453 f) (_a$8454 (jolt-invoke f acc (jolt-get node (keyword #f "obj")))) (_a$8455 (jolt-get node (keyword #f "val")))) (jolt-invoke _a$8453 _a$8454 _a$8455)) (if (jolt= op (keyword #f "defmacro")) (jolt-invoke f acc (jolt-get node (keyword #f "fn"))) (if (jolt= op (keyword #f "ffi-callable")) (jolt-invoke f acc (jolt-get node (keyword #f "fn"))) (if (jolt= op (keyword #f "invoke")) (let* ((_a$8456 f) (_a$8457 (jolt-invoke f acc (jolt-get node (keyword #f "fn")))) (_a$8458 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$8456 _a$8457 _a$8458)) (if (jolt= op (keyword #f "vector")) (jolt-reduce f acc (jolt-get node (keyword #f "items"))) (if (jolt= op (keyword #f "set")) (jolt-reduce f acc (jolt-get node (keyword #f "items"))) (if (jolt= op (keyword #f "map")) (let* ((_a$8463 (lambda (a pr) (let fnrec8459 ((a a) (pr pr)) (let* ((_a$8460 f) (_a$8461 (jolt-invoke f a (jolt-nth pr 0))) (_a$8462 (jolt-nth pr 1))) (jolt-invoke _a$8460 _a$8461 _a$8462))))) (_a$8464 acc) (_a$8465 (jolt-get node (keyword #f "pairs")))) (jolt-reduce _a$8463 _a$8464 _a$8465)) (if (jolt= op (keyword #f "let")) (let* ((_a$8470 f) (_a$8471 (let* ((_a$8467 (lambda (a b) (let fnrec8466 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$8468 acc) (_a$8469 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$8467 _a$8468 _a$8469))) (_a$8472 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$8470 _a$8471 _a$8472)) (if (jolt= op (keyword #f "loop")) (let* ((_a$8477 f) (_a$8478 (let* ((_a$8474 (lambda (a b) (let fnrec8473 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$8475 acc) (_a$8476 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$8474 _a$8475 _a$8476))) (_a$8479 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$8477 _a$8478 _a$8479)) (if (jolt= op (keyword #f "recur")) (jolt-reduce f acc (jolt-get node (keyword #f "args"))) (if (jolt= op (keyword #f "fn")) (let* ((_a$8481 (lambda (a ar) (let fnrec8480 ((a a) (ar ar)) (jolt-invoke f a (jolt-get ar (keyword #f "body")))))) (_a$8482 acc) (_a$8483 (jolt-get node (keyword #f "arities")))) (jolt-reduce _a$8481 _a$8482 _a$8483)) (if (jolt= op (keyword #f "def")) (let* ((a (if (jolt-truthy? (jolt-get node (keyword #f "init"))) (jolt-invoke f acc (jolt-get node (keyword #f "init"))) acc))) (if (jolt-truthy? (jolt-get node (keyword #f "meta-expr"))) (jolt-invoke f a (jolt-get node (keyword #f "meta-expr"))) a)) (if (jolt= op (keyword #f "host-call")) (let* ((_a$8484 f) (_a$8485 (jolt-invoke f acc (jolt-get node (keyword #f "target")))) (_a$8486 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$8484 _a$8485 _a$8486)) (if (jolt= op (keyword #f "host-new")) (jolt-reduce f acc (jolt-get node (keyword #f "args"))) (if (jolt= op (keyword #f "try")) (let* ((a (jolt-invoke f acc (jolt-get node (keyword #f "body")))) (a (if (jolt-truthy? (jolt-get node (keyword #f "catch-body"))) (jolt-invoke f a (jolt-get node (keyword #f "catch-body"))) a)) (a (if (jolt-truthy? (jolt-get node (keyword #f "finally"))) (jolt-invoke f a (jolt-get node (keyword #f "finally"))) a))) a) (if (jolt-truthy? (keyword #f "else")) acc jolt-nil)))))))))))))))))))))))))) reduce-ir-children))) + (def-var! "jolt.ir" "reduce-ir-children" (letrec ((reduce-ir-children (lambda (f acc node) (let fnrec8478 ((f f) (acc acc) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$8482 f) (_a$8483 (let* ((_a$8479 f) (_a$8480 (jolt-invoke f acc (jolt-get node (keyword #f "test")))) (_a$8481 (jolt-get node (keyword #f "then")))) (jolt-invoke _a$8479 _a$8480 _a$8481))) (_a$8484 (jolt-get node (keyword #f "else")))) (jolt-invoke _a$8482 _a$8483 _a$8484)) (if (jolt= op (keyword #f "do")) (let* ((_a$8485 f) (_a$8486 (jolt-reduce f acc (jolt-get node (keyword #f "statements")))) (_a$8487 (jolt-get node (keyword #f "ret")))) (jolt-invoke _a$8485 _a$8486 _a$8487)) (if (jolt= op (keyword #f "throw")) (jolt-invoke f acc (jolt-get node (keyword #f "expr"))) (if (jolt= op (keyword #f "coerce")) (jolt-invoke f acc (jolt-get node (keyword #f "expr"))) (if (jolt= op (keyword #f "set-var")) (jolt-invoke f acc (jolt-get node (keyword #f "val"))) (if (jolt= op (keyword #f "set-field")) (let* ((_a$8488 f) (_a$8489 (jolt-invoke f acc (jolt-get node (keyword #f "obj")))) (_a$8490 (jolt-get node (keyword #f "val")))) (jolt-invoke _a$8488 _a$8489 _a$8490)) (if (jolt= op (keyword #f "defmacro")) (jolt-invoke f acc (jolt-get node (keyword #f "fn"))) (if (jolt= op (keyword #f "ffi-callable")) (jolt-invoke f acc (jolt-get node (keyword #f "fn"))) (if (jolt= op (keyword #f "invoke")) (let* ((_a$8491 f) (_a$8492 (jolt-invoke f acc (jolt-get node (keyword #f "fn")))) (_a$8493 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$8491 _a$8492 _a$8493)) (if (jolt= op (keyword #f "vector")) (jolt-reduce f acc (jolt-get node (keyword #f "items"))) (if (jolt= op (keyword #f "set")) (jolt-reduce f acc (jolt-get node (keyword #f "items"))) (if (jolt= op (keyword #f "map")) (let* ((_a$8498 (lambda (a pr) (let fnrec8494 ((a a) (pr pr)) (let* ((_a$8495 f) (_a$8496 (jolt-invoke f a (jolt-nth pr 0))) (_a$8497 (jolt-nth pr 1))) (jolt-invoke _a$8495 _a$8496 _a$8497))))) (_a$8499 acc) (_a$8500 (jolt-get node (keyword #f "pairs")))) (jolt-reduce _a$8498 _a$8499 _a$8500)) (if (jolt= op (keyword #f "let")) (let* ((_a$8505 f) (_a$8506 (let* ((_a$8502 (lambda (a b) (let fnrec8501 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$8503 acc) (_a$8504 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$8502 _a$8503 _a$8504))) (_a$8507 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$8505 _a$8506 _a$8507)) (if (jolt= op (keyword #f "loop")) (let* ((_a$8512 f) (_a$8513 (let* ((_a$8509 (lambda (a b) (let fnrec8508 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$8510 acc) (_a$8511 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$8509 _a$8510 _a$8511))) (_a$8514 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$8512 _a$8513 _a$8514)) (if (jolt= op (keyword #f "recur")) (jolt-reduce f acc (jolt-get node (keyword #f "args"))) (if (jolt= op (keyword #f "fn")) (let* ((_a$8516 (lambda (a ar) (let fnrec8515 ((a a) (ar ar)) (jolt-invoke f a (jolt-get ar (keyword #f "body")))))) (_a$8517 acc) (_a$8518 (jolt-get node (keyword #f "arities")))) (jolt-reduce _a$8516 _a$8517 _a$8518)) (if (jolt= op (keyword #f "def")) (let* ((a (if (jolt-truthy? (jolt-get node (keyword #f "init"))) (jolt-invoke f acc (jolt-get node (keyword #f "init"))) acc))) (if (jolt-truthy? (jolt-get node (keyword #f "meta-expr"))) (jolt-invoke f a (jolt-get node (keyword #f "meta-expr"))) a)) (if (jolt= op (keyword #f "host-call")) (let* ((_a$8519 f) (_a$8520 (jolt-invoke f acc (jolt-get node (keyword #f "target")))) (_a$8521 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$8519 _a$8520 _a$8521)) (if (jolt= op (keyword #f "host-new")) (jolt-reduce f acc (jolt-get node (keyword #f "args"))) (if (jolt= op (keyword #f "try")) (let* ((a (jolt-invoke f acc (jolt-get node (keyword #f "body")))) (a (if (jolt-truthy? (jolt-get node (keyword #f "catch-body"))) (jolt-invoke f a (jolt-get node (keyword #f "catch-body"))) a)) (a (if (jolt-truthy? (jolt-get node (keyword #f "finally"))) (jolt-invoke f a (jolt-get node (keyword #f "finally"))) a))) a) (if (jolt-truthy? (keyword #f "else")) acc jolt-nil)))))))))))))))))))))))))) reduce-ir-children))) (guard (e (#t #f)) (declare-var! "jolt.analyzer" "analyze")) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "handled" (let* ((_o$8487 "quote") (_o$8488 "if") (_o$8489 "do") (_o$8490 "def") (_o$8491 "fn*") (_o$8492 "let*") (_o$8493 "loop*") (_o$8494 "recur") (_o$8495 "throw") (_o$8496 "try") (_o$8497 "syntax-quote") (_o$8498 "var") (_o$8499 "letfn*") (_o$8500 "set!") (_o$8501 "defmacro")) (jolt-hash-set _o$8487 _o$8488 _o$8489 _o$8490 _o$8491 _o$8492 _o$8493 _o$8494 _o$8495 _o$8496 _o$8497 _o$8498 _o$8499 _o$8500 _o$8501)) (let* ((_o$8502 (keyword #f "private")) (_o$8503 #t)) (jolt-hash-map _o$8502 _o$8503)))) + (def-var-with-meta! "jolt.analyzer" "handled" (let* ((_o$8522 "quote") (_o$8523 "if") (_o$8524 "do") (_o$8525 "def") (_o$8526 "fn*") (_o$8527 "let*") (_o$8528 "loop*") (_o$8529 "recur") (_o$8530 "throw") (_o$8531 "try") (_o$8532 "syntax-quote") (_o$8533 "var") (_o$8534 "letfn*") (_o$8535 "set!") (_o$8536 "defmacro")) (jolt-hash-set _o$8522 _o$8523 _o$8524 _o$8525 _o$8526 _o$8527 _o$8528 _o$8529 _o$8530 _o$8531 _o$8532 _o$8533 _o$8534 _o$8535 _o$8536)) (let* ((_o$8537 (keyword #f "private")) (_o$8538 #t)) (jolt-hash-map _o$8537 _o$8538)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "uncompilable" (letrec ((uncompilable (lambda (why) (let fnrec8504 ((why why)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt/uncompilable: " why)))))) uncompilable) (let* ((_o$8505 (keyword #f "private")) (_o$8506 #t)) (jolt-hash-map _o$8505 _o$8506)))) + (def-var-with-meta! "jolt.analyzer" "uncompilable" (letrec ((uncompilable (lambda (why) (let fnrec8539 ((why why)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt/uncompilable: " why)))))) uncompilable) (let* ((_o$8540 (keyword #f "private")) (_o$8541 #t)) (jolt-hash-map _o$8540 _o$8541)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "gensym-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$8507 (keyword #f "private")) (_o$8508 #t)) (jolt-hash-map _o$8507 _o$8508)))) + (def-var-with-meta! "jolt.analyzer" "gensym-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$8542 (keyword #f "private")) (_o$8543 #t)) (jolt-hash-map _o$8542 _o$8543)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "gen-name" (letrec ((gen-name (lambda (prefix) (let fnrec8509 ((prefix prefix)) (let* ((n (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.analyzer" "gensym-counter")))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.analyzer" "gensym-counter") jolt-inc) (jolt-invoke (var-deref "clojure.core" "str") "_r$" prefix n))))))) gen-name) (let* ((_o$8510 (keyword #f "private")) (_o$8511 #t)) (jolt-hash-map _o$8510 _o$8511)))) + (def-var-with-meta! "jolt.analyzer" "gen-name" (letrec ((gen-name (lambda (prefix) (let fnrec8544 ((prefix prefix)) (let* ((n (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.analyzer" "gensym-counter")))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.analyzer" "gensym-counter") jolt-inc) (jolt-invoke (var-deref "clojure.core" "str") "_r$" prefix n))))))) gen-name) (let* ((_o$8545 (keyword #f "private")) (_o$8546 #t)) (jolt-hash-map _o$8545 _o$8546)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "empty-env" (letrec ((empty-env (lambda () (let fnrec8512 () (let* ((_o$8513 (keyword #f "locals")) (_o$8514 (jolt-hash-set)) (_o$8515 (keyword #f "hints")) (_o$8516 (jolt-hash-map))) (jolt-hash-map _o$8513 _o$8514 _o$8515 _o$8516)))))) empty-env) (let* ((_o$8517 (keyword #f "private")) (_o$8518 #t)) (jolt-hash-map _o$8517 _o$8518)))) + (def-var-with-meta! "jolt.analyzer" "empty-env" (letrec ((empty-env (lambda () (let fnrec8547 () (let* ((_o$8548 (keyword #f "locals")) (_o$8549 (jolt-hash-set)) (_o$8550 (keyword #f "hints")) (_o$8551 (jolt-hash-map))) (jolt-hash-map _o$8548 _o$8549 _o$8550 _o$8551)))))) empty-env) (let* ((_o$8552 (keyword #f "private")) (_o$8553 #t)) (jolt-hash-map _o$8552 _o$8553)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "local?" (letrec ((local? (lambda (env nm) (let fnrec8519 ((env env) (nm nm)) (jolt-contains? (jolt-get env (keyword #f "locals")) nm))))) local?) (let* ((_o$8520 (keyword #f "private")) (_o$8521 #t)) (jolt-hash-map _o$8520 _o$8521)))) + (def-var-with-meta! "jolt.analyzer" "local?" (letrec ((local? (lambda (env nm) (let fnrec8554 ((env env) (nm nm)) (jolt-contains? (jolt-get env (keyword #f "locals")) nm))))) local?) (let* ((_o$8555 (keyword #f "private")) (_o$8556 #t)) (jolt-hash-map _o$8555 _o$8556)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "add-locals" (letrec ((add-locals (lambda (env names) (let fnrec8522 ((env env) (names names)) (jolt-invoke (var-deref "clojure.core" "update") env (keyword #f "locals") (lambda (p__90_) (let fnrec8523 ((p__90_ p__90_)) (jolt-reduce jolt-conj p__90_ names)))))))) add-locals) (let* ((_o$8524 (keyword #f "private")) (_o$8525 #t)) (jolt-hash-map _o$8524 _o$8525)))) + (def-var-with-meta! "jolt.analyzer" "add-locals" (letrec ((add-locals (lambda (env names) (let fnrec8557 ((env env) (names names)) (jolt-invoke (var-deref "clojure.core" "update") env (keyword #f "locals") (lambda (p__97_) (let fnrec8558 ((p__97_ p__97_)) (jolt-reduce jolt-conj p__97_ names)))))))) add-locals) (let* ((_o$8559 (keyword #f "private")) (_o$8560 #t)) (jolt-hash-map _o$8559 _o$8560)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "amp-env-map" (letrec ((amp-env-map (lambda (env) (let fnrec8526 ((env env)) (let* ((_a$8528 (lambda (m n) (let fnrec8527 ((m m) (n n)) (jolt-assoc m (jolt-invoke (var-deref "clojure.core" "symbol") n) jolt-nil)))) (_a$8529 (jolt-hash-map)) (_a$8530 (jolt-get env (keyword #f "locals")))) (jolt-reduce _a$8528 _a$8529 _a$8530)))))) amp-env-map) (let* ((_o$8531 (keyword #f "private")) (_o$8532 #t)) (jolt-hash-map _o$8531 _o$8532)))) + (def-var-with-meta! "jolt.analyzer" "amp-env-map" (letrec ((amp-env-map (lambda (env) (let fnrec8561 ((env env)) (let* ((_a$8563 (lambda (m n) (let fnrec8562 ((m m) (n n)) (jolt-assoc m (jolt-invoke (var-deref "clojure.core" "symbol") n) jolt-nil)))) (_a$8564 (jolt-hash-map)) (_a$8565 (jolt-get env (keyword #f "locals")))) (jolt-reduce _a$8563 _a$8564 _a$8565)))))) amp-env-map) (let* ((_o$8566 (keyword #f "private")) (_o$8567 #t)) (jolt-hash-map _o$8566 _o$8567)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "with-recur" (letrec ((with-recur (lambda (env name) (let fnrec8533 ((env env) (name name)) (jolt-assoc env (keyword #f "recur") name))))) with-recur) (let* ((_o$8534 (keyword #f "private")) (_o$8535 #t)) (jolt-hash-map _o$8534 _o$8535)))) + (def-var-with-meta! "jolt.analyzer" "with-recur" (letrec ((with-recur (lambda (env name) (let fnrec8568 ((env env) (name name)) (jolt-assoc env (keyword #f "recur") name))))) with-recur) (let* ((_o$8569 (keyword #f "private")) (_o$8570 #t)) (jolt-hash-map _o$8569 _o$8570)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "hint-of" (letrec ((hint-of (lambda (ctx sym) (let fnrec8536 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-nil? m) jolt-nil (if (jolt-truthy? (jolt-get m (keyword #f "struct"))) (keyword #f "struct") (if (jolt-truthy? (keyword #f "else")) (let* ((t (jolt-get m (keyword #f "tag")))) (if (jolt-truthy? (let* ((and__25__auto t)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "record-type?") ctx t) and__25__auto))) (keyword #f "struct") jolt-nil)) jolt-nil)))))))) hint-of) (let* ((_o$8537 (keyword #f "private")) (_o$8538 #t)) (jolt-hash-map _o$8537 _o$8538)))) + (def-var-with-meta! "jolt.analyzer" "hint-of" (letrec ((hint-of (lambda (ctx sym) (let fnrec8571 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-nil? m) jolt-nil (if (jolt-truthy? (jolt-get m (keyword #f "struct"))) (keyword #f "struct") (if (jolt-truthy? (keyword #f "else")) (let* ((t (jolt-get m (keyword #f "tag")))) (if (jolt-truthy? (let* ((and__25__auto t)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "record-type?") ctx t) and__25__auto))) (keyword #f "struct") jolt-nil)) jolt-nil)))))))) hint-of) (let* ((_o$8572 (keyword #f "private")) (_o$8573 #t)) (jolt-hash-map _o$8572 _o$8573)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "add-hint" (letrec ((add-hint (lambda (env nm h) (let fnrec8539 ((env env) (nm nm) (h h)) (if (jolt-truthy? h) (jolt-assoc env (keyword #f "hints") (jolt-assoc (jolt-get env (keyword #f "hints")) nm h)) env))))) add-hint) (let* ((_o$8540 (keyword #f "private")) (_o$8541 #t)) (jolt-hash-map _o$8540 _o$8541)))) + (def-var-with-meta! "jolt.analyzer" "add-hint" (letrec ((add-hint (lambda (env nm h) (let fnrec8574 ((env env) (nm nm) (h h)) (if (jolt-truthy? h) (jolt-assoc env (keyword #f "hints") (jolt-assoc (jolt-get env (keyword #f "hints")) nm h)) env))))) add-hint) (let* ((_o$8575 (keyword #f "private")) (_o$8576 #t)) (jolt-hash-map _o$8575 _o$8576)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "phint-of" (letrec ((phint-of (lambda (ctx sym) (let fnrec8542 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-truthy? m) (let* ((t (jolt-get m (keyword #f "tag")))) (if (jolt-truthy? t) (jolt-invoke (var-deref "jolt.host" "record-ctor-key") ctx t) jolt-nil)) jolt-nil)))))) phint-of) (let* ((_o$8543 (keyword #f "private")) (_o$8544 #t)) (jolt-hash-map _o$8543 _o$8544)))) + (def-var-with-meta! "jolt.analyzer" "phint-of" (letrec ((phint-of (lambda (ctx sym) (let fnrec8577 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-truthy? m) (let* ((t (jolt-get m (keyword #f "tag")))) (if (jolt-truthy? t) (jolt-invoke (var-deref "jolt.host" "record-ctor-key") ctx t) jolt-nil)) jolt-nil)))))) phint-of) (let* ((_o$8578 (keyword #f "private")) (_o$8579 #t)) (jolt-hash-map _o$8578 _o$8579)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "tag->nkind" (letrec ((tag->nkind (lambda (t) (let fnrec8545 ((t t)) (let* ((s (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") t)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") t) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") t)) t (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))) (if (jolt= s "double") (keyword #f "double") (if (jolt= s "long") (keyword #f "long") (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))))))) tag->nkind) (let* ((_o$8546 (keyword #f "private")) (_o$8547 #t)) (jolt-hash-map _o$8546 _o$8547)))) + (def-var-with-meta! "jolt.analyzer" "tag->nkind" (letrec ((tag->nkind (lambda (t) (let fnrec8580 ((t t)) (let* ((s (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") t)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") t) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") t)) t (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))) (if (jolt= s "double") (keyword #f "double") (if (jolt= s "long") (keyword #f "long") (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))))))) tag->nkind) (let* ((_o$8581 (keyword #f "private")) (_o$8582 #t)) (jolt-hash-map _o$8581 _o$8582)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "nhint-of" (letrec ((nhint-of (lambda (ctx sym) (let fnrec8548 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-truthy? m) (jolt-invoke (var-deref "jolt.analyzer" "tag->nkind") (jolt-get m (keyword #f "tag"))) jolt-nil)))))) nhint-of) (let* ((_o$8549 (keyword #f "private")) (_o$8550 #t)) (jolt-hash-map _o$8549 _o$8550)))) + (def-var-with-meta! "jolt.analyzer" "nhint-of" (letrec ((nhint-of (lambda (ctx sym) (let fnrec8583 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-truthy? m) (jolt-invoke (var-deref "jolt.analyzer" "tag->nkind") (jolt-get m (keyword #f "tag"))) jolt-nil)))))) nhint-of) (let* ((_o$8584 (keyword #f "private")) (_o$8585 #t)) (jolt-hash-map _o$8584 _o$8585)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "with-ret-nhint" (letrec ((with-ret-nhint (lambda (node kind) (let fnrec8551 ((node node) (kind kind)) (if (jolt-truthy? (let* ((and__25__auto kind)) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "fn") (jolt-get node (keyword #f "op"))) and__25__auto))) (jolt-assoc node (keyword #f "arities") (let* ((_a$8553 (var-deref "clojure.core" "mapv")) (_a$8554 (lambda (a) (let fnrec8552 ((a a)) (if (jolt-truthy? (jolt-get a (keyword #f "ret-nhint"))) a (jolt-assoc a (keyword #f "ret-nhint") kind))))) (_a$8555 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$8553 _a$8554 _a$8555))) node))))) with-ret-nhint) (let* ((_o$8556 (keyword #f "private")) (_o$8557 #t)) (jolt-hash-map _o$8556 _o$8557)))) + (def-var-with-meta! "jolt.analyzer" "with-ret-nhint" (letrec ((with-ret-nhint (lambda (node kind) (let fnrec8586 ((node node) (kind kind)) (if (jolt-truthy? (let* ((and__25__auto kind)) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "fn") (jolt-get node (keyword #f "op"))) and__25__auto))) (jolt-assoc node (keyword #f "arities") (let* ((_a$8588 (var-deref "clojure.core" "mapv")) (_a$8589 (lambda (a) (let fnrec8587 ((a a)) (if (jolt-truthy? (jolt-get a (keyword #f "ret-nhint"))) a (jolt-assoc a (keyword #f "ret-nhint") kind))))) (_a$8590 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$8588 _a$8589 _a$8590))) node))))) with-ret-nhint) (let* ((_o$8591 (keyword #f "private")) (_o$8592 #t)) (jolt-hash-map _o$8591 _o$8592)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-seq" (letrec ((analyze-seq (lambda (ctx forms env) (let fnrec8558 ((ctx ctx) (forms forms) (env env)) (let* ((v (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__91_) (let fnrec8559 ((p__91_ p__91_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__91_ env))) forms)) (n (jolt-count v))) (if (jolt-zero? n) (jolt-invoke (var-deref "jolt.ir" "const") jolt-nil) (if (jolt= 1 n) (jolt-first v) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$8560 (var-deref "jolt.ir" "do-node")) (_a$8561 (jolt-invoke (var-deref "clojure.core" "subvec") v 0 (jolt-dec n))) (_a$8562 (jolt-peek v))) (jolt-invoke _a$8560 _a$8561 _a$8562)) jolt-nil)))))))) analyze-seq) (let* ((_o$8563 (keyword #f "private")) (_o$8564 #t)) (jolt-hash-map _o$8563 _o$8564)))) + (def-var-with-meta! "jolt.analyzer" "analyze-seq" (letrec ((analyze-seq (lambda (ctx forms env) (let fnrec8593 ((ctx ctx) (forms forms) (env env)) (let* ((v (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__98_) (let fnrec8594 ((p__98_ p__98_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__98_ env))) forms)) (n (jolt-count v))) (if (jolt-zero? n) (jolt-invoke (var-deref "jolt.ir" "const") jolt-nil) (if (jolt= 1 n) (jolt-first v) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$8595 (var-deref "jolt.ir" "do-node")) (_a$8596 (jolt-invoke (var-deref "clojure.core" "subvec") v 0 (jolt-dec n))) (_a$8597 (jolt-peek v))) (jolt-invoke _a$8595 _a$8596 _a$8597)) jolt-nil)))))))) analyze-seq) (let* ((_o$8598 (keyword #f "private")) (_o$8599 #t)) (jolt-hash-map _o$8598 _o$8599)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-bindings" (letrec ((analyze-bindings (lambda (ctx bvec env) (let fnrec8565 ((ctx ctx) (bvec bvec) (env env)) (let* ((i 0) (env env) (pairs (jolt-vector))) (let loop8566 ((i i) (env env) (pairs pairs)) (if (< i (jolt-count bvec)) (let* ((bsym (jolt-nth bvec i))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") bsym)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "destructuring binding") jolt-nil) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") bsym)) (init (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth bvec (jolt-inc i)) env))) (let* ((_a$8573 (+ i 2)) (_a$8574 (let* ((_a$8567 (var-deref "jolt.analyzer" "add-hint")) (_a$8568 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector nm))) (_a$8569 nm) (_a$8570 (jolt-invoke (var-deref "jolt.analyzer" "hint-of") ctx bsym))) (jolt-invoke _a$8567 _a$8568 _a$8569 _a$8570))) (_a$8575 (jolt-conj pairs (let* ((_o$8571 nm) (_o$8572 init)) (jolt-vector _o$8571 _o$8572))))) (loop8566 _a$8573 _a$8574 _a$8575))))) (let* ((_o$8576 pairs) (_o$8577 env)) (jolt-vector _o$8576 _o$8577))))))))) analyze-bindings) (let* ((_o$8578 (keyword #f "private")) (_o$8579 #t)) (jolt-hash-map _o$8578 _o$8579)))) + (def-var-with-meta! "jolt.analyzer" "analyze-bindings" (letrec ((analyze-bindings (lambda (ctx bvec env) (let fnrec8600 ((ctx ctx) (bvec bvec) (env env)) (let* ((i 0) (env env) (pairs (jolt-vector))) (let loop8601 ((i i) (env env) (pairs pairs)) (if (< i (jolt-count bvec)) (let* ((bsym (jolt-nth bvec i))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") bsym)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "destructuring binding") jolt-nil) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") bsym)) (init (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth bvec (jolt-inc i)) env))) (let* ((_a$8608 (+ i 2)) (_a$8609 (let* ((_a$8602 (var-deref "jolt.analyzer" "add-hint")) (_a$8603 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector nm))) (_a$8604 nm) (_a$8605 (jolt-invoke (var-deref "jolt.analyzer" "hint-of") ctx bsym))) (jolt-invoke _a$8602 _a$8603 _a$8604 _a$8605))) (_a$8610 (jolt-conj pairs (let* ((_o$8606 nm) (_o$8607 init)) (jolt-vector _o$8606 _o$8607))))) (loop8601 _a$8608 _a$8609 _a$8610))))) (let* ((_o$8611 pairs) (_o$8612 env)) (jolt-vector _o$8611 _o$8612))))))))) analyze-bindings) (let* ((_o$8613 (keyword #f "private")) (_o$8614 #t)) (jolt-hash-map _o$8613 _o$8614)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "parse-params" (letrec ((parse-params (lambda (ctx pvec) (let fnrec8580 ((ctx ctx) (pvec pvec)) (let* ((i 0) (fixed (jolt-vector)) (rest-name jolt-nil) (hints (jolt-vector)) (phints (jolt-vector)) (nhints (jolt-vector))) (let loop8581 ((i i) (fixed fixed) (rest-name rest-name) (hints hints) (phints phints) (nhints nhints)) (if (< i (jolt-count pvec)) (let* ((p (jolt-nth pvec i))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") p)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "destructuring fn param") jolt-nil) (if (jolt= "&" (jolt-invoke (var-deref "jolt.host" "form-sym-name") p)) (let* ((r (jolt-nth pvec (jolt-inc i)))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") r)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "destructuring fn rest") jolt-nil) (let* ((_a$8582 (+ i 2)) (_a$8583 fixed) (_a$8584 (jolt-invoke (var-deref "jolt.host" "form-sym-name") r)) (_a$8585 hints) (_a$8586 phints) (_a$8587 nhints)) (loop8581 _a$8582 _a$8583 _a$8584 _a$8585 _a$8586 _a$8587)))) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") p)) (h (jolt-invoke (var-deref "jolt.analyzer" "hint-of") ctx p)) (ph (jolt-invoke (var-deref "jolt.analyzer" "phint-of") ctx p)) (nh (jolt-invoke (var-deref "jolt.analyzer" "nhint-of") ctx p))) (let* ((_a$8594 (jolt-inc i)) (_a$8595 (jolt-conj fixed nm)) (_a$8596 rest-name) (_a$8597 (if (jolt-truthy? h) (jolt-conj hints (let* ((_o$8588 nm) (_o$8589 h)) (jolt-vector _o$8588 _o$8589))) hints)) (_a$8598 (if (jolt-truthy? ph) (jolt-conj phints (let* ((_o$8590 nm) (_o$8591 ph)) (jolt-vector _o$8590 _o$8591))) phints)) (_a$8599 (if (jolt-truthy? nh) (jolt-conj nhints (let* ((_o$8592 nm) (_o$8593 nh)) (jolt-vector _o$8592 _o$8593))) nhints))) (loop8581 _a$8594 _a$8595 _a$8596 _a$8597 _a$8598 _a$8599)))))) (let* ((_o$8600 (keyword #f "fixed")) (_o$8601 fixed) (_o$8602 (keyword #f "rest")) (_o$8603 rest-name) (_o$8604 (keyword #f "hints")) (_o$8605 hints) (_o$8606 (keyword #f "phints")) (_o$8607 phints) (_o$8608 (keyword #f "nhints")) (_o$8609 nhints)) (jolt-hash-map _o$8600 _o$8601 _o$8602 _o$8603 _o$8604 _o$8605 _o$8606 _o$8607 _o$8608 _o$8609))))))))) parse-params) (let* ((_o$8610 (keyword #f "private")) (_o$8611 #t)) (jolt-hash-map _o$8610 _o$8611)))) + (def-var-with-meta! "jolt.analyzer" "parse-params" (letrec ((parse-params (lambda (ctx pvec) (let fnrec8615 ((ctx ctx) (pvec pvec)) (let* ((i 0) (fixed (jolt-vector)) (rest-name jolt-nil) (hints (jolt-vector)) (phints (jolt-vector)) (nhints (jolt-vector))) (let loop8616 ((i i) (fixed fixed) (rest-name rest-name) (hints hints) (phints phints) (nhints nhints)) (if (< i (jolt-count pvec)) (let* ((p (jolt-nth pvec i))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") p)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "destructuring fn param") jolt-nil) (if (jolt= "&" (jolt-invoke (var-deref "jolt.host" "form-sym-name") p)) (let* ((r (jolt-nth pvec (jolt-inc i)))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") r)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "destructuring fn rest") jolt-nil) (let* ((_a$8617 (+ i 2)) (_a$8618 fixed) (_a$8619 (jolt-invoke (var-deref "jolt.host" "form-sym-name") r)) (_a$8620 hints) (_a$8621 phints) (_a$8622 nhints)) (loop8616 _a$8617 _a$8618 _a$8619 _a$8620 _a$8621 _a$8622)))) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") p)) (h (jolt-invoke (var-deref "jolt.analyzer" "hint-of") ctx p)) (ph (jolt-invoke (var-deref "jolt.analyzer" "phint-of") ctx p)) (nh (jolt-invoke (var-deref "jolt.analyzer" "nhint-of") ctx p))) (let* ((_a$8629 (jolt-inc i)) (_a$8630 (jolt-conj fixed nm)) (_a$8631 rest-name) (_a$8632 (if (jolt-truthy? h) (jolt-conj hints (let* ((_o$8623 nm) (_o$8624 h)) (jolt-vector _o$8623 _o$8624))) hints)) (_a$8633 (if (jolt-truthy? ph) (jolt-conj phints (let* ((_o$8625 nm) (_o$8626 ph)) (jolt-vector _o$8625 _o$8626))) phints)) (_a$8634 (if (jolt-truthy? nh) (jolt-conj nhints (let* ((_o$8627 nm) (_o$8628 nh)) (jolt-vector _o$8627 _o$8628))) nhints))) (loop8616 _a$8629 _a$8630 _a$8631 _a$8632 _a$8633 _a$8634)))))) (let* ((_o$8635 (keyword #f "fixed")) (_o$8636 fixed) (_o$8637 (keyword #f "rest")) (_o$8638 rest-name) (_o$8639 (keyword #f "hints")) (_o$8640 hints) (_o$8641 (keyword #f "phints")) (_o$8642 phints) (_o$8643 (keyword #f "nhints")) (_o$8644 nhints)) (jolt-hash-map _o$8635 _o$8636 _o$8637 _o$8638 _o$8639 _o$8640 _o$8641 _o$8642 _o$8643 _o$8644))))))))) parse-params) (let* ((_o$8645 (keyword #f "private")) (_o$8646 #t)) (jolt-hash-map _o$8645 _o$8646)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "uniquify-params" (letrec ((uniquify-params (lambda (names) (let fnrec8612 ((names names)) (let* ((n (jolt-count names))) (let* ((i 0) (out (jolt-vector))) (let loop8613 ((i i) (out out)) (if (< i n) (let* ((nm (jolt-nth names i)) (dup? (let* ((j (jolt-inc i))) (let loop8614 ((j j)) (if (>= j n) #f (if (jolt= nm (jolt-nth names j)) #t (if (jolt-truthy? (keyword #f "else")) (loop8614 (jolt-inc j)) jolt-nil))))))) (let* ((_a$8615 (jolt-inc i)) (_a$8616 (jolt-conj out (if (jolt-truthy? dup?) (jolt-invoke (var-deref "jolt.analyzer" "gen-name") (jolt-invoke (var-deref "clojure.core" "str") nm "_")) nm)))) (loop8613 _a$8615 _a$8616))) out)))))))) uniquify-params) (let* ((_o$8617 (keyword #f "private")) (_o$8618 #t)) (jolt-hash-map _o$8617 _o$8618)))) + (def-var-with-meta! "jolt.analyzer" "uniquify-params" (letrec ((uniquify-params (lambda (names) (let fnrec8647 ((names names)) (let* ((n (jolt-count names))) (let* ((i 0) (out (jolt-vector))) (let loop8648 ((i i) (out out)) (if (< i n) (let* ((nm (jolt-nth names i)) (dup? (let* ((j (jolt-inc i))) (let loop8649 ((j j)) (if (>= j n) #f (if (jolt= nm (jolt-nth names j)) #t (if (jolt-truthy? (keyword #f "else")) (loop8649 (jolt-inc j)) jolt-nil))))))) (let* ((_a$8650 (jolt-inc i)) (_a$8651 (jolt-conj out (if (jolt-truthy? dup?) (jolt-invoke (var-deref "jolt.analyzer" "gen-name") (jolt-invoke (var-deref "clojure.core" "str") nm "_")) nm)))) (loop8648 _a$8650 _a$8651))) out)))))))) uniquify-params) (let* ((_o$8652 (keyword #f "private")) (_o$8653 #t)) (jolt-hash-map _o$8652 _o$8653)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-arity" (letrec ((analyze-arity (lambda (ctx pvec body env fn-name) (let fnrec8619 ((ctx ctx) (pvec pvec) (body body) (env env) (fn-name fn-name)) (let* ((pp (jolt-invoke (var-deref "jolt.analyzer" "parse-params") ctx (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") pvec)))) (fixed (jolt-invoke (var-deref "jolt.analyzer" "uniquify-params") (jolt-get pp (keyword #f "fixed")))) (rst (jolt-get pp (keyword #f "rest"))) (rname (jolt-invoke (var-deref "jolt.analyzer" "gen-name") (let* ((_a$8620 (var-deref "clojure.core" "str")) (_a$8621 (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (_a$8622 "/") (_a$8623 (let* ((or__26__auto fn-name)) (if (jolt-truthy? or__26__auto) or__26__auto "fn"))) (_a$8624 "--")) (jolt-invoke _a$8620 _a$8621 _a$8622 _a$8623 _a$8624)))) (names (let* ((G__148 (jolt-invoke (var-deref "clojure.core" "vec") fixed))) (let* ((G__149 (if (jolt-truthy? rst) (jolt-conj G__148 rst) G__148))) (let* ((G__150 (if (jolt-truthy? fn-name) (jolt-conj G__149 fn-name) G__149))) G__150)))) (env0 (jolt-invoke (var-deref "jolt.analyzer" "with-recur") (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names) rname)) (env* (let* ((_a$8630 (lambda (e pr) (let fnrec8625 ((e e) (pr pr)) (let* ((_a$8626 (var-deref "jolt.analyzer" "add-hint")) (_a$8627 e) (_a$8628 (jolt-nth pr 0)) (_a$8629 (jolt-nth pr 1))) (jolt-invoke _a$8626 _a$8627 _a$8628 _a$8629))))) (_a$8631 env0) (_a$8632 (jolt-get pp (keyword #f "hints")))) (jolt-reduce _a$8630 _a$8631 _a$8632))) (arity (let* ((_o$8633 (keyword #f "params")) (_o$8634 fixed) (_o$8635 (keyword #f "recur-name")) (_o$8636 rname) (_o$8637 (keyword #f "body")) (_o$8638 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx body env*))) (jolt-hash-map _o$8633 _o$8634 _o$8635 _o$8636 _o$8637 _o$8638))) (arity (if (jolt-truthy? (jolt-seq (jolt-get pp (keyword #f "phints")))) (jolt-assoc arity (keyword #f "phints") (jolt-get pp (keyword #f "phints"))) arity)) (arity (if (jolt-truthy? (jolt-seq (jolt-get pp (keyword #f "nhints")))) (jolt-assoc arity (keyword #f "nhints") (jolt-get pp (keyword #f "nhints"))) arity))) (if (jolt-truthy? rst) (jolt-assoc arity (keyword #f "rest") rst) arity)))))) analyze-arity) (let* ((_o$8639 (keyword #f "private")) (_o$8640 #t)) (jolt-hash-map _o$8639 _o$8640)))) + (def-var-with-meta! "jolt.analyzer" "analyze-arity" (letrec ((analyze-arity (lambda (ctx pvec body env fn-name) (let fnrec8654 ((ctx ctx) (pvec pvec) (body body) (env env) (fn-name fn-name)) (let* ((pp (jolt-invoke (var-deref "jolt.analyzer" "parse-params") ctx (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") pvec)))) (fixed (jolt-invoke (var-deref "jolt.analyzer" "uniquify-params") (jolt-get pp (keyword #f "fixed")))) (rst (jolt-get pp (keyword #f "rest"))) (rname (jolt-invoke (var-deref "jolt.analyzer" "gen-name") (let* ((_a$8655 (var-deref "clojure.core" "str")) (_a$8656 (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (_a$8657 "/") (_a$8658 (let* ((or__26__auto fn-name)) (if (jolt-truthy? or__26__auto) or__26__auto "fn"))) (_a$8659 "--")) (jolt-invoke _a$8655 _a$8656 _a$8657 _a$8658 _a$8659)))) (names (let* ((G__148 (jolt-invoke (var-deref "clojure.core" "vec") fixed))) (let* ((G__149 (if (jolt-truthy? rst) (jolt-conj G__148 rst) G__148))) (let* ((G__150 (if (jolt-truthy? fn-name) (jolt-conj G__149 fn-name) G__149))) G__150)))) (env0 (jolt-invoke (var-deref "jolt.analyzer" "with-recur") (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names) rname)) (env* (let* ((_a$8665 (lambda (e pr) (let fnrec8660 ((e e) (pr pr)) (let* ((_a$8661 (var-deref "jolt.analyzer" "add-hint")) (_a$8662 e) (_a$8663 (jolt-nth pr 0)) (_a$8664 (jolt-nth pr 1))) (jolt-invoke _a$8661 _a$8662 _a$8663 _a$8664))))) (_a$8666 env0) (_a$8667 (jolt-get pp (keyword #f "hints")))) (jolt-reduce _a$8665 _a$8666 _a$8667))) (arity (let* ((_o$8668 (keyword #f "params")) (_o$8669 fixed) (_o$8670 (keyword #f "recur-name")) (_o$8671 rname) (_o$8672 (keyword #f "body")) (_o$8673 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx body env*))) (jolt-hash-map _o$8668 _o$8669 _o$8670 _o$8671 _o$8672 _o$8673))) (arity (if (jolt-truthy? (jolt-seq (jolt-get pp (keyword #f "phints")))) (jolt-assoc arity (keyword #f "phints") (jolt-get pp (keyword #f "phints"))) arity)) (arity (if (jolt-truthy? (jolt-seq (jolt-get pp (keyword #f "nhints")))) (jolt-assoc arity (keyword #f "nhints") (jolt-get pp (keyword #f "nhints"))) arity))) (if (jolt-truthy? rst) (jolt-assoc arity (keyword #f "rest") rst) arity)))))) analyze-arity) (let* ((_o$8674 (keyword #f "private")) (_o$8675 #t)) (jolt-hash-map _o$8674 _o$8675)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "strip-arglist-meta" (letrec ((strip-arglist-meta (lambda (form) (let fnrec8641 ((form form)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") form)) (let* ((es (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") form)))) (if (jolt-truthy? (let* ((and__25__auto (jolt= 3 (jolt-count es)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-first es)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "with-meta" (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first es))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-vec?") (jolt-nth es 1)) and__25__auto)) and__25__auto)) and__25__auto))) (jolt-nth es 1) form)) form))))) strip-arglist-meta) (let* ((_o$8642 (keyword #f "private")) (_o$8643 #t)) (jolt-hash-map _o$8642 _o$8643)))) + (def-var-with-meta! "jolt.analyzer" "strip-arglist-meta" (letrec ((strip-arglist-meta (lambda (form) (let fnrec8676 ((form form)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") form)) (let* ((es (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") form)))) (if (jolt-truthy? (let* ((and__25__auto (jolt= 3 (jolt-count es)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-first es)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "with-meta" (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first es))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-vec?") (jolt-nth es 1)) and__25__auto)) and__25__auto)) and__25__auto))) (jolt-nth es 1) form)) form))))) strip-arglist-meta) (let* ((_o$8677 (keyword #f "private")) (_o$8678 #t)) (jolt-hash-map _o$8677 _o$8678)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-fn" (letrec ((analyze-fn (lambda (ctx items env) (let fnrec8644 ((ctx ctx) (items items) (env env)) (let* ((named (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth items 1))) (fn-name (if (jolt-truthy? named) (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth items 1)) jolt-nil)) (rest-items (if (jolt-truthy? named) (jolt-drop 2 items) (jolt-drop 1 items))) (first* (jolt-invoke (var-deref "jolt.analyzer" "strip-arglist-meta") (jolt-first rest-items)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-vec?") first*)) (jolt-invoke (var-deref "jolt.ir" "fn-node") fn-name (jolt-vector (jolt-invoke (var-deref "jolt.analyzer" "analyze-arity") ctx first* (jolt-rest rest-items) env fn-name))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") first*)) (jolt-invoke (var-deref "jolt.ir" "fn-node") fn-name (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (clause) (let fnrec8645 ((clause clause)) (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") clause)))) (let* ((_a$8646 (var-deref "jolt.analyzer" "analyze-arity")) (_a$8647 ctx) (_a$8648 (jolt-invoke (var-deref "jolt.analyzer" "strip-arglist-meta") (jolt-first cl))) (_a$8649 (jolt-rest cl)) (_a$8650 env) (_a$8651 fn-name)) (jolt-invoke _a$8646 _a$8647 _a$8648 _a$8649 _a$8650 _a$8651))))) rest-items)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "fn: bad params") jolt-nil)))))))) analyze-fn) (let* ((_o$8652 (keyword #f "private")) (_o$8653 #t)) (jolt-hash-map _o$8652 _o$8653)))) + (def-var-with-meta! "jolt.analyzer" "analyze-fn" (letrec ((analyze-fn (lambda (ctx items env) (let fnrec8679 ((ctx ctx) (items items) (env env)) (let* ((named (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth items 1))) (fn-name (if (jolt-truthy? named) (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth items 1)) jolt-nil)) (rest-items (if (jolt-truthy? named) (jolt-drop 2 items) (jolt-drop 1 items))) (first* (jolt-invoke (var-deref "jolt.analyzer" "strip-arglist-meta") (jolt-first rest-items)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-vec?") first*)) (jolt-invoke (var-deref "jolt.ir" "fn-node") fn-name (jolt-vector (jolt-invoke (var-deref "jolt.analyzer" "analyze-arity") ctx first* (jolt-rest rest-items) env fn-name))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") first*)) (jolt-invoke (var-deref "jolt.ir" "fn-node") fn-name (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (clause) (let fnrec8680 ((clause clause)) (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") clause)))) (let* ((_a$8681 (var-deref "jolt.analyzer" "analyze-arity")) (_a$8682 ctx) (_a$8683 (jolt-invoke (var-deref "jolt.analyzer" "strip-arglist-meta") (jolt-first cl))) (_a$8684 (jolt-rest cl)) (_a$8685 env) (_a$8686 fn-name)) (jolt-invoke _a$8681 _a$8682 _a$8683 _a$8684 _a$8685 _a$8686))))) rest-items)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "fn: bad params") jolt-nil)))))))) analyze-fn) (let* ((_o$8687 (keyword #f "private")) (_o$8688 #t)) (jolt-hash-map _o$8687 _o$8688)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "catch-all-names" (let* ((_o$8654 "Throwable") (_o$8655 "java.lang.Throwable") (_o$8656 "Object") (_o$8657 "java.lang.Object")) (jolt-hash-set _o$8654 _o$8655 _o$8656 _o$8657)) (let* ((_o$8658 (keyword #f "private")) (_o$8659 #t)) (jolt-hash-map _o$8658 _o$8659)))) + (def-var-with-meta! "jolt.analyzer" "catch-all-names" (let* ((_o$8689 "Throwable") (_o$8690 "java.lang.Throwable") (_o$8691 "Object") (_o$8692 "java.lang.Object")) (jolt-hash-set _o$8689 _o$8690 _o$8691 _o$8692)) (let* ((_o$8693 (keyword #f "private")) (_o$8694 #t)) (jolt-hash-map _o$8693 _o$8694)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-try" (letrec ((analyze-try (lambda (ctx items env) (let fnrec8660 ((ctx ctx) (items items) (env env)) (let* ((clauses (jolt-rest items)) (body (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))) (catches (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))) (finally-body (jolt-invoke (var-deref "clojure.core" "atom") jolt-nil))) (begin (begin (jolt-count (jolt-map (lambda (c) (let fnrec8661 ((c c)) (begin (let* ((head (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") c)) (jolt-first (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") c))) jolt-nil)) (hname (if (jolt-truthy? (let* ((and__25__auto head)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") head) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") head) jolt-nil))) (if (jolt= hname "catch") (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") c)))) (begin (if (let* ((or__26__auto (< (jolt-count cl) 3))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth cl 2))))) (jolt-throw "Unable to parse catch clause; expected (catch class binding body*)") jolt-nil) (jolt-invoke (var-deref "clojure.core" "swap!") catches jolt-conj cl))) (if (jolt= hname "finally") (jolt-invoke (var-deref "clojure.core" "reset!") finally-body (jolt-rest (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") c)))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "swap!") body jolt-conj c) jolt-nil)))) jolt-nil))) clauses)) jolt-nil) (let* ((n (let* ((_o$8662 (keyword #f "op")) (_o$8663 (keyword #f "try")) (_o$8664 (keyword #f "body")) (_o$8665 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-invoke (var-deref "clojure.core" "deref") body) env))) (jolt-hash-map _o$8662 _o$8663 _o$8664 _o$8665))) (n (if (jolt-truthy? (jolt-seq (jolt-invoke (var-deref "clojure.core" "deref") catches))) (let* ((evar-name (jolt-invoke (var-deref "jolt.analyzer" "gen-name") "catch")) (evar (jolt-invoke (var-deref "clojure.core" "symbol") evar-name)) (dispatch (let* ((_a$8670 (lambda (_else cl) (let fnrec8666 ((_else _else) (cl cl)) (let* ((cform (jolt-nth cl 1)) (bindsym (jolt-nth cl 2)) (bodyf (jolt-drop 3 cl)) (letform (jolt-cons (jolt-symbol #f "let") (jolt-cons (jolt-vector bindsym evar) bodyf))) (fullname (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") cform)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") cform) jolt-nil)) (catch-all? (let* ((or__26__auto (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") cform)))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-contains? (var-deref "jolt.analyzer" "catch-all-names") fullname))))) (if (jolt-truthy? catch-all?) letform (jolt-list (jolt-symbol #f "if") (let* ((_a$8667 (jolt-symbol #f "or")) (_a$8668 (jolt-list (jolt-symbol #f "instance?") cform evar)) (_a$8669 (jolt-list (jolt-symbol #f "__catch-broad?") fullname evar))) (jolt-list _a$8667 _a$8668 _a$8669)) letform _else)))))) (_a$8671 (jolt-list (jolt-symbol #f "throw") evar)) (_a$8672 (jolt-reverse (jolt-invoke (var-deref "clojure.core" "deref") catches)))) (jolt-reduce _a$8670 _a$8671 _a$8672)))) (jolt-assoc n (keyword #f "catch-sym") evar-name (keyword #f "catch-body") (let* ((_a$8673 (var-deref "jolt.analyzer" "analyze-seq")) (_a$8674 ctx) (_a$8675 (jolt-list dispatch)) (_a$8676 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector evar-name)))) (jolt-invoke _a$8673 _a$8674 _a$8675 _a$8676)))) n)) (n (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "deref") finally-body)) (jolt-assoc n (keyword #f "finally") (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-invoke (var-deref "clojure.core" "deref") finally-body) env)) n))) n))))))) analyze-try) (let* ((_o$8677 (keyword #f "private")) (_o$8678 #t)) (jolt-hash-map _o$8677 _o$8678)))) + (def-var-with-meta! "jolt.analyzer" "analyze-try" (letrec ((analyze-try (lambda (ctx items env) (let fnrec8695 ((ctx ctx) (items items) (env env)) (let* ((clauses (jolt-rest items)) (body (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))) (catches (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))) (finally-body (jolt-invoke (var-deref "clojure.core" "atom") jolt-nil))) (begin (begin (jolt-count (jolt-map (lambda (c) (let fnrec8696 ((c c)) (begin (let* ((head (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") c)) (jolt-first (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") c))) jolt-nil)) (hname (if (jolt-truthy? (let* ((and__25__auto head)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") head) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") head) jolt-nil))) (if (jolt= hname "catch") (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") c)))) (begin (if (let* ((or__26__auto (< (jolt-count cl) 3))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth cl 2))))) (jolt-throw "Unable to parse catch clause; expected (catch class binding body*)") jolt-nil) (jolt-invoke (var-deref "clojure.core" "swap!") catches jolt-conj cl))) (if (jolt= hname "finally") (jolt-invoke (var-deref "clojure.core" "reset!") finally-body (jolt-rest (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") c)))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "swap!") body jolt-conj c) jolt-nil)))) jolt-nil))) clauses)) jolt-nil) (let* ((n (let* ((_o$8697 (keyword #f "op")) (_o$8698 (keyword #f "try")) (_o$8699 (keyword #f "body")) (_o$8700 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-invoke (var-deref "clojure.core" "deref") body) env))) (jolt-hash-map _o$8697 _o$8698 _o$8699 _o$8700))) (n (if (jolt-truthy? (jolt-seq (jolt-invoke (var-deref "clojure.core" "deref") catches))) (let* ((evar-name (jolt-invoke (var-deref "jolt.analyzer" "gen-name") "catch")) (evar (jolt-invoke (var-deref "clojure.core" "symbol") evar-name)) (dispatch (let* ((_a$8705 (lambda (_else cl) (let fnrec8701 ((_else _else) (cl cl)) (let* ((cform (jolt-nth cl 1)) (bindsym (jolt-nth cl 2)) (bodyf (jolt-drop 3 cl)) (letform (jolt-cons (jolt-symbol #f "let") (jolt-cons (jolt-vector bindsym evar) bodyf))) (fullname (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") cform)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") cform) jolt-nil)) (catch-all? (let* ((or__26__auto (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") cform)))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-contains? (var-deref "jolt.analyzer" "catch-all-names") fullname))))) (if (jolt-truthy? catch-all?) letform (jolt-list (jolt-symbol #f "if") (let* ((_a$8702 (jolt-symbol #f "or")) (_a$8703 (jolt-list (jolt-symbol #f "instance?") cform evar)) (_a$8704 (jolt-list (jolt-symbol #f "__catch-broad?") fullname evar))) (jolt-list _a$8702 _a$8703 _a$8704)) letform _else)))))) (_a$8706 (jolt-list (jolt-symbol #f "throw") evar)) (_a$8707 (jolt-reverse (jolt-invoke (var-deref "clojure.core" "deref") catches)))) (jolt-reduce _a$8705 _a$8706 _a$8707)))) (jolt-assoc n (keyword #f "catch-sym") evar-name (keyword #f "catch-body") (let* ((_a$8708 (var-deref "jolt.analyzer" "analyze-seq")) (_a$8709 ctx) (_a$8710 (jolt-list dispatch)) (_a$8711 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector evar-name)))) (jolt-invoke _a$8708 _a$8709 _a$8710 _a$8711)))) n)) (n (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "deref") finally-body)) (jolt-assoc n (keyword #f "finally") (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-invoke (var-deref "clojure.core" "deref") finally-body) env)) n))) n))))))) analyze-try) (let* ((_o$8712 (keyword #f "private")) (_o$8713 #t)) (jolt-hash-map _o$8712 _o$8713)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-letfn*" (letrec ((analyze-letfn* (lambda (ctx items env) (let fnrec8679 ((ctx ctx) (items items) (env env)) (let* ((bvec (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 1)))) (n (quotient (jolt-count bvec) 2)) (names (let* ((_a$8681 (var-deref "clojure.core" "mapv")) (_a$8682 (lambda (i) (let fnrec8680 ((i i)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth bvec (* 2 i)))))) (_a$8683 (jolt-range n))) (jolt-invoke _a$8681 _a$8682 _a$8683))) (env* (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names)) (binds (let* ((_a$8687 (var-deref "clojure.core" "mapv")) (_a$8688 (lambda (i) (let fnrec8684 ((i i)) (let* ((_o$8685 (jolt-nth names i)) (_o$8686 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth bvec (jolt-inc (* 2 i))) env*))) (jolt-vector _o$8685 _o$8686))))) (_a$8689 (jolt-range n))) (jolt-invoke _a$8687 _a$8688 _a$8689)))) (let* ((_o$8690 (keyword #f "op")) (_o$8691 (keyword #f "let")) (_o$8692 (keyword #f "letrec")) (_o$8693 #t) (_o$8694 (keyword #f "bindings")) (_o$8695 binds) (_o$8696 (keyword #f "body")) (_o$8697 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env*))) (jolt-hash-map _o$8690 _o$8691 _o$8692 _o$8693 _o$8694 _o$8695 _o$8696 _o$8697))))))) analyze-letfn*) (let* ((_o$8698 (keyword #f "private")) (_o$8699 #t)) (jolt-hash-map _o$8698 _o$8699)))) + (def-var-with-meta! "jolt.analyzer" "analyze-letfn*" (letrec ((analyze-letfn* (lambda (ctx items env) (let fnrec8714 ((ctx ctx) (items items) (env env)) (let* ((bvec (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 1)))) (n (quotient (jolt-count bvec) 2)) (names (let* ((_a$8716 (var-deref "clojure.core" "mapv")) (_a$8717 (lambda (i) (let fnrec8715 ((i i)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth bvec (* 2 i)))))) (_a$8718 (jolt-range n))) (jolt-invoke _a$8716 _a$8717 _a$8718))) (env* (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names)) (binds (let* ((_a$8722 (var-deref "clojure.core" "mapv")) (_a$8723 (lambda (i) (let fnrec8719 ((i i)) (let* ((_o$8720 (jolt-nth names i)) (_o$8721 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth bvec (jolt-inc (* 2 i))) env*))) (jolt-vector _o$8720 _o$8721))))) (_a$8724 (jolt-range n))) (jolt-invoke _a$8722 _a$8723 _a$8724)))) (let* ((_o$8725 (keyword #f "op")) (_o$8726 (keyword #f "let")) (_o$8727 (keyword #f "letrec")) (_o$8728 #t) (_o$8729 (keyword #f "bindings")) (_o$8730 binds) (_o$8731 (keyword #f "body")) (_o$8732 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env*))) (jolt-hash-map _o$8725 _o$8726 _o$8727 _o$8728 _o$8729 _o$8730 _o$8731 _o$8732))))))) analyze-letfn*) (let* ((_o$8733 (keyword #f "private")) (_o$8734 #t)) (jolt-hash-map _o$8733 _o$8734)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "field-head?" (letrec ((field-head? (lambda (nm) (let fnrec8700 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 2))) (if (jolt-truthy? and__25__auto) (jolt= ".-" (jolt-invoke (var-deref "clojure.core" "subs") nm 0 2)) and__25__auto)))))) field-head?) (let* ((_o$8701 (keyword #f "private")) (_o$8702 #t)) (jolt-hash-map _o$8701 _o$8702)))) + (def-var-with-meta! "jolt.analyzer" "field-head?" (letrec ((field-head? (lambda (nm) (let fnrec8735 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 2))) (if (jolt-truthy? and__25__auto) (jolt= ".-" (jolt-invoke (var-deref "clojure.core" "subs") nm 0 2)) and__25__auto)))))) field-head?) (let* ((_o$8736 (keyword #f "private")) (_o$8737 #t)) (jolt-hash-map _o$8736 _o$8737)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "def-meta-expr" (letrec ((def-meta-expr (lambda (ctx base env) (let fnrec8703 ((ctx ctx) (base base) (env env)) (if (jolt-pos? (jolt-count base)) (jolt-invoke (var-deref "jolt.ir" "map-node") (let* ((_a$8707 (var-deref "clojure.core" "mapv")) (_a$8708 (lambda (p) (let fnrec8704 ((p p)) (let* ((k (jolt-first p)) (v (jolt-invoke (var-deref "clojure.core" "second") p))) (let* ((_o$8705 (jolt-invoke (var-deref "jolt.ir" "const") k)) (_o$8706 (if (jolt= k (keyword #f "tag")) (jolt-invoke (var-deref "jolt.ir" "quote-node") v) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx v env)))) (jolt-vector _o$8705 _o$8706)))))) (_a$8709 (jolt-seq base))) (jolt-invoke _a$8707 _a$8708 _a$8709))) jolt-nil))))) def-meta-expr) (let* ((_o$8710 (keyword #f "private")) (_o$8711 #t)) (jolt-hash-map _o$8710 _o$8711)))) + (def-var-with-meta! "jolt.analyzer" "def-meta-expr" (letrec ((def-meta-expr (lambda (ctx base env) (let fnrec8738 ((ctx ctx) (base base) (env env)) (if (jolt-pos? (jolt-count base)) (jolt-invoke (var-deref "jolt.ir" "map-node") (let* ((_a$8742 (var-deref "clojure.core" "mapv")) (_a$8743 (lambda (p) (let fnrec8739 ((p p)) (let* ((k (jolt-first p)) (v (jolt-invoke (var-deref "clojure.core" "second") p))) (let* ((_o$8740 (jolt-invoke (var-deref "jolt.ir" "const") k)) (_o$8741 (if (jolt= k (keyword #f "tag")) (jolt-invoke (var-deref "jolt.ir" "quote-node") v) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx v env)))) (jolt-vector _o$8740 _o$8741)))))) (_a$8744 (jolt-seq base))) (jolt-invoke _a$8742 _a$8743 _a$8744))) jolt-nil))))) def-meta-expr) (let* ((_o$8745 (keyword #f "private")) (_o$8746 #t)) (jolt-hash-map _o$8745 _o$8746)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-def" (letrec ((analyze-def (lambda (ctx items env) (let fnrec8712 ((ctx ctx) (items items) (env env)) (let* ((name-sym (jolt-nth items 1))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") name-sym)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "def name with map metadata") jolt-nil) (if (< (jolt-count items) 3) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") name-sym)) (cur (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx))) (begin (jolt-invoke (var-deref "jolt.host" "host-intern!") ctx cur nm) (let* ((_o$8713 (keyword #f "op")) (_o$8714 (keyword #f "def")) (_o$8715 (keyword #f "ns")) (_o$8716 cur) (_o$8717 (keyword #f "name")) (_o$8718 nm) (_o$8719 (keyword #f "no-init")) (_o$8720 #t)) (jolt-hash-map _o$8713 _o$8714 _o$8715 _o$8716 _o$8717 _o$8718 _o$8719 _o$8720)))) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") name-sym)) (cur (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (has-doc (let* ((and__25__auto (> (jolt-count items) 3))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "string?") (jolt-nth items 2)) and__25__auto))) (val-form (jolt-nth items (if (jolt-truthy? has-doc) 3 2))) (base0 (let* ((or__26__auto (jolt-invoke (var-deref "jolt.host" "form-sym-meta") name-sym))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-hash-map)))) (tag (jolt-get base0 (keyword #f "tag"))) (tag-name (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") tag)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") tag) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") tag)) tag (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))) (base-meta (if (jolt-truthy? tag-name) (let* ((c (jolt-invoke (var-deref "jolt.host" "resolve-class-hint") tag-name))) (if (jolt-truthy? c) (jolt-assoc base0 (keyword #f "tag") c) base0)) base0)) (node-meta (if (jolt-truthy? has-doc) (jolt-assoc base-meta (keyword #f "doc") (jolt-nth items 2)) base-meta))) (begin (jolt-invoke (var-deref "jolt.host" "host-intern!") ctx cur nm) (let* ((node (jolt-invoke (var-deref "jolt.ir" "def-node") cur nm (let* ((_a$8721 (var-deref "jolt.analyzer" "with-ret-nhint")) (_a$8722 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx val-form env)) (_a$8723 (jolt-invoke (var-deref "jolt.analyzer" "tag->nkind") tag))) (jolt-invoke _a$8721 _a$8722 _a$8723)) node-meta)) (me (jolt-invoke (var-deref "jolt.analyzer" "def-meta-expr") ctx node-meta env))) (if (jolt-truthy? me) (jolt-assoc node (keyword #f "meta-expr") me) node))))))))))) analyze-def) (let* ((_o$8724 (keyword #f "private")) (_o$8725 #t)) (jolt-hash-map _o$8724 _o$8725)))) + (def-var-with-meta! "jolt.analyzer" "analyze-def" (letrec ((analyze-def (lambda (ctx items env) (let fnrec8747 ((ctx ctx) (items items) (env env)) (let* ((name-sym (jolt-nth items 1))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") name-sym)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "def name with map metadata") jolt-nil) (if (< (jolt-count items) 3) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") name-sym)) (cur (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx))) (begin (jolt-invoke (var-deref "jolt.host" "host-intern!") ctx cur nm) (let* ((_o$8748 (keyword #f "op")) (_o$8749 (keyword #f "def")) (_o$8750 (keyword #f "ns")) (_o$8751 cur) (_o$8752 (keyword #f "name")) (_o$8753 nm) (_o$8754 (keyword #f "no-init")) (_o$8755 #t)) (jolt-hash-map _o$8748 _o$8749 _o$8750 _o$8751 _o$8752 _o$8753 _o$8754 _o$8755)))) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") name-sym)) (cur (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (has-doc (let* ((and__25__auto (> (jolt-count items) 3))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "string?") (jolt-nth items 2)) and__25__auto))) (val-form (jolt-nth items (if (jolt-truthy? has-doc) 3 2))) (base0 (let* ((or__26__auto (jolt-invoke (var-deref "jolt.host" "form-sym-meta") name-sym))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-hash-map)))) (tag (jolt-get base0 (keyword #f "tag"))) (tag-name (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") tag)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") tag) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") tag)) tag (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))) (base-meta (if (jolt-truthy? tag-name) (let* ((c (jolt-invoke (var-deref "jolt.host" "resolve-class-hint") tag-name))) (if (jolt-truthy? c) (jolt-assoc base0 (keyword #f "tag") c) base0)) base0)) (node-meta (if (jolt-truthy? has-doc) (jolt-assoc base-meta (keyword #f "doc") (jolt-nth items 2)) base-meta))) (begin (jolt-invoke (var-deref "jolt.host" "host-intern!") ctx cur nm) (let* ((node (jolt-invoke (var-deref "jolt.ir" "def-node") cur nm (let* ((_a$8756 (var-deref "jolt.analyzer" "with-ret-nhint")) (_a$8757 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx val-form env)) (_a$8758 (jolt-invoke (var-deref "jolt.analyzer" "tag->nkind") tag))) (jolt-invoke _a$8756 _a$8757 _a$8758)) node-meta)) (me (jolt-invoke (var-deref "jolt.analyzer" "def-meta-expr") ctx node-meta env))) (if (jolt-truthy? me) (jolt-assoc node (keyword #f "meta-expr") me) node))))))))))) analyze-def) (let* ((_o$8759 (keyword #f "private")) (_o$8760 #t)) (jolt-hash-map _o$8759 _o$8760)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-set!" (letrec ((analyze-set! (lambda (ctx items env) (let fnrec8726 ((ctx ctx) (items items) (env env)) (let* ((target (jolt-nth items 1)) (val-node (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 2) env)) (ti (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") target)) (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") target)) jolt-nil)) (thead (if (jolt-truthy? (let* ((and__25__auto ti)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-pos? (jolt-count ti)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-first ti)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first ti)) jolt-nil))) (if (jolt-truthy? (let* ((and__25__auto thead)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "field-head?") thead) and__25__auto))) (let* ((_o$8727 (keyword #f "op")) (_o$8728 (keyword #f "set-field")) (_o$8729 (keyword #f "obj")) (_o$8730 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth ti 1) env)) (_o$8731 (keyword #f "field")) (_o$8732 (jolt-invoke (var-deref "clojure.core" "subs") thead 2)) (_o$8733 (keyword #f "val")) (_o$8734 val-node)) (jolt-hash-map _o$8727 _o$8728 _o$8729 _o$8730 _o$8731 _o$8732 _o$8733 _o$8734)) (if (jolt-truthy? (let* ((and__25__auto (jolt= thead "."))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= (jolt-count ti) 3))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth ti 1)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth ti 2)))) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "class") (jolt-get (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx (jolt-nth ti 1)) (keyword #f "kind"))) and__25__auto)) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((_a$8738 (var-deref "jolt.ir" "invoke")) (_a$8739 (jolt-invoke (var-deref "jolt.ir" "var-ref") "jolt.host" "set-static-field!")) (_a$8740 (let* ((_o$8735 (jolt-invoke (var-deref "jolt.ir" "const") (jolt-get (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx (jolt-nth ti 1)) (keyword #f "name")))) (_o$8736 (jolt-invoke (var-deref "jolt.ir" "const") (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth ti 2)))) (_o$8737 val-node)) (jolt-vector _o$8735 _o$8736 _o$8737)))) (jolt-invoke _a$8738 _a$8739 _a$8740)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") target)) (begin (if (jolt-truthy? (jolt-invoke (var-deref "jolt.analyzer" "local?") env (jolt-invoke (var-deref "jolt.host" "form-sym-name") target))) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "set! of a local") jolt-nil) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx target))) (begin (if (jolt-not (jolt= (keyword #f "var") (jolt-get r (keyword #f "kind")))) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "set! of a non-var") jolt-nil) (let* ((_o$8744 (keyword #f "op")) (_o$8745 (keyword #f "set-var")) (_o$8746 (keyword #f "the-var")) (_o$8747 (let* ((_a$8741 (var-deref "jolt.ir" "the-var")) (_a$8742 (jolt-get r (keyword #f "ns"))) (_a$8743 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8741 _a$8742 _a$8743))) (_o$8748 (keyword #f "val")) (_o$8749 val-node)) (jolt-hash-map _o$8744 _o$8745 _o$8746 _o$8747 _o$8748 _o$8749))))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "set! of an unsupported target") jolt-nil))))))))) analyze-set!) (let* ((_o$8750 (keyword #f "private")) (_o$8751 #t)) (jolt-hash-map _o$8750 _o$8751)))) + (def-var-with-meta! "jolt.analyzer" "analyze-set!" (letrec ((analyze-set! (lambda (ctx items env) (let fnrec8761 ((ctx ctx) (items items) (env env)) (let* ((target (jolt-nth items 1)) (val-node (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 2) env)) (ti (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") target)) (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") target)) jolt-nil)) (thead (if (jolt-truthy? (let* ((and__25__auto ti)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-pos? (jolt-count ti)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-first ti)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first ti)) jolt-nil))) (if (jolt-truthy? (let* ((and__25__auto thead)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "field-head?") thead) and__25__auto))) (let* ((_o$8762 (keyword #f "op")) (_o$8763 (keyword #f "set-field")) (_o$8764 (keyword #f "obj")) (_o$8765 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth ti 1) env)) (_o$8766 (keyword #f "field")) (_o$8767 (jolt-invoke (var-deref "clojure.core" "subs") thead 2)) (_o$8768 (keyword #f "val")) (_o$8769 val-node)) (jolt-hash-map _o$8762 _o$8763 _o$8764 _o$8765 _o$8766 _o$8767 _o$8768 _o$8769)) (if (jolt-truthy? (let* ((and__25__auto (jolt= thead "."))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= (jolt-count ti) 3))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth ti 1)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth ti 2)))) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "class") (jolt-get (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx (jolt-nth ti 1)) (keyword #f "kind"))) and__25__auto)) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((_a$8773 (var-deref "jolt.ir" "invoke")) (_a$8774 (jolt-invoke (var-deref "jolt.ir" "var-ref") "jolt.host" "set-static-field!")) (_a$8775 (let* ((_o$8770 (jolt-invoke (var-deref "jolt.ir" "const") (jolt-get (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx (jolt-nth ti 1)) (keyword #f "name")))) (_o$8771 (jolt-invoke (var-deref "jolt.ir" "const") (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth ti 2)))) (_o$8772 val-node)) (jolt-vector _o$8770 _o$8771 _o$8772)))) (jolt-invoke _a$8773 _a$8774 _a$8775)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") target)) (begin (if (jolt-truthy? (jolt-invoke (var-deref "jolt.analyzer" "local?") env (jolt-invoke (var-deref "jolt.host" "form-sym-name") target))) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "set! of a local") jolt-nil) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx target))) (begin (if (jolt-not (jolt= (keyword #f "var") (jolt-get r (keyword #f "kind")))) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "set! of a non-var") jolt-nil) (let* ((_o$8779 (keyword #f "op")) (_o$8780 (keyword #f "set-var")) (_o$8781 (keyword #f "the-var")) (_o$8782 (let* ((_a$8776 (var-deref "jolt.ir" "the-var")) (_a$8777 (jolt-get r (keyword #f "ns"))) (_a$8778 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8776 _a$8777 _a$8778))) (_o$8783 (keyword #f "val")) (_o$8784 val-node)) (jolt-hash-map _o$8779 _o$8780 _o$8781 _o$8782 _o$8783 _o$8784))))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "set! of an unsupported target") jolt-nil))))))))) analyze-set!) (let* ((_o$8785 (keyword #f "private")) (_o$8786 #t)) (jolt-hash-map _o$8785 _o$8786)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-special" (letrec ((analyze-special (lambda (ctx op items env) (let fnrec8752 ((ctx ctx) (op op) (items items) (env env)) (let* ((G__151 op)) (if (jolt= G__151 "quote") (jolt-invoke (var-deref "jolt.ir" "quote-node") (jolt-invoke (var-deref "clojure.core" "second") items)) (if (jolt= G__151 "if") (begin (if (let* ((or__26__auto (< (jolt-count items) 3))) (if (jolt-truthy? or__26__auto) or__26__auto (> (jolt-count items) 4))) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Wrong number of args (" (jolt-dec (jolt-count items)) ") passed to: if")) jolt-nil) (let* ((_a$8753 (var-deref "jolt.ir" "if-node")) (_a$8754 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_a$8755 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 2) env)) (_a$8756 (if (> (jolt-count items) 3) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 3) env) (jolt-invoke (var-deref "jolt.ir" "const") jolt-nil)))) (jolt-invoke _a$8753 _a$8754 _a$8755 _a$8756))) (if (jolt= G__151 "do") (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-rest items) env) (if (jolt= G__151 "throw") (jolt-invoke (var-deref "jolt.ir" "throw-node") (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (if (jolt= G__151 "def") (jolt-invoke (var-deref "jolt.analyzer" "analyze-def") ctx items env) (if (jolt= G__151 "let*") (let* ((bvec (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 1)))) (r (jolt-invoke (var-deref "jolt.analyzer" "analyze-bindings") ctx bvec env))) (let* ((_a$8761 (var-deref "jolt.ir" "let-node")) (_a$8762 (jolt-first r)) (_a$8763 (let* ((_a$8757 (var-deref "jolt.analyzer" "analyze-seq")) (_a$8758 ctx) (_a$8759 (jolt-drop 2 items)) (_a$8760 (jolt-invoke (var-deref "clojure.core" "second") r))) (jolt-invoke _a$8757 _a$8758 _a$8759 _a$8760)))) (jolt-invoke _a$8761 _a$8762 _a$8763))) (if (jolt= G__151 "loop*") (let* ((bvec (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 1)))) (rname (jolt-invoke (var-deref "jolt.analyzer" "gen-name") "loop")) (r (jolt-invoke (var-deref "jolt.analyzer" "analyze-bindings") ctx bvec env)) (env** (jolt-invoke (var-deref "jolt.analyzer" "with-recur") (jolt-invoke (var-deref "clojure.core" "second") r) rname))) (let* ((_o$8764 (keyword #f "op")) (_o$8765 (keyword #f "loop")) (_o$8766 (keyword #f "recur-name")) (_o$8767 rname) (_o$8768 (keyword #f "bindings")) (_o$8769 (jolt-first r)) (_o$8770 (keyword #f "body")) (_o$8771 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env**))) (jolt-hash-map _o$8764 _o$8765 _o$8766 _o$8767 _o$8768 _o$8769 _o$8770 _o$8771))) (if (jolt= G__151 "recur") (let* ((rt (jolt-get env (keyword #f "recur")))) (begin (if (jolt-not rt) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "recur outside loop/fn") jolt-nil) (let* ((_o$8776 (keyword #f "op")) (_o$8777 (keyword #f "recur")) (_o$8778 (keyword #f "recur-name")) (_o$8779 rt) (_o$8780 (keyword #f "args")) (_o$8781 (let* ((_a$8773 (var-deref "clojure.core" "mapv")) (_a$8774 (lambda (p__92_) (let fnrec8772 ((p__92_ p__92_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__92_ env)))) (_a$8775 (jolt-rest items))) (jolt-invoke _a$8773 _a$8774 _a$8775)))) (jolt-hash-map _o$8776 _o$8777 _o$8778 _o$8779 _o$8780 _o$8781)))) (if (jolt= G__151 "try") (jolt-invoke (var-deref "jolt.analyzer" "analyze-try") ctx items env) (if (jolt= G__151 "letfn*") (jolt-invoke (var-deref "jolt.analyzer" "analyze-letfn*") ctx items env) (if (jolt= G__151 "fn*") (jolt-invoke (var-deref "jolt.analyzer" "analyze-fn") ctx items env) (if (jolt= G__151 "syntax-quote") (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-invoke (var-deref "jolt.host" "form-syntax-quote-lower") ctx (jolt-invoke (var-deref "clojure.core" "second") items)) env) (if (jolt= G__151 "var") (let* ((sym (jolt-invoke (var-deref "clojure.core" "second") items)) (r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx sym))) (if (jolt= (keyword #f "var") (jolt-get r (keyword #f "kind"))) (let* ((_a$8782 (var-deref "jolt.ir" "the-var")) (_a$8783 (jolt-get r (keyword #f "ns"))) (_a$8784 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8782 _a$8783 _a$8784)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "var of non-var " (jolt-invoke (var-deref "jolt.host" "form-sym-name") sym))))) (if (jolt= G__151 "defmacro") (let* ((name-sym (jolt-nth items 1)) (nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") name-sym)) (cur (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (after (jolt-drop 2 items)) (after (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") (jolt-first after))) (jolt-rest after) after)) (after (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-map?") (jolt-first after))) (jolt-rest after) after)) (fn-form (jolt-cons (jolt-invoke (var-deref "clojure.core" "symbol") "fn") after))) (begin (jolt-invoke (var-deref "jolt.host" "host-intern!") ctx cur nm) (let* ((_o$8785 (keyword #f "op")) (_o$8786 (keyword #f "defmacro")) (_o$8787 (keyword #f "ns")) (_o$8788 cur) (_o$8789 (keyword #f "name")) (_o$8790 nm) (_o$8791 (keyword #f "fn")) (_o$8792 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx fn-form env))) (jolt-hash-map _o$8785 _o$8786 _o$8787 _o$8788 _o$8789 _o$8790 _o$8791 _o$8792)))) (if (jolt= G__151 "set!") (jolt-invoke (var-deref "jolt.analyzer" "analyze-set!") ctx items env) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "special form " op)))))))))))))))))))))) analyze-special) (let* ((_o$8793 (keyword #f "private")) (_o$8794 #t)) (jolt-hash-map _o$8793 _o$8794)))) + (def-var-with-meta! "jolt.analyzer" "analyze-special" (letrec ((analyze-special (lambda (ctx op items env) (let fnrec8787 ((ctx ctx) (op op) (items items) (env env)) (let* ((G__151 op)) (if (jolt= G__151 "quote") (jolt-invoke (var-deref "jolt.ir" "quote-node") (jolt-invoke (var-deref "clojure.core" "second") items)) (if (jolt= G__151 "if") (begin (if (let* ((or__26__auto (< (jolt-count items) 3))) (if (jolt-truthy? or__26__auto) or__26__auto (> (jolt-count items) 4))) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Wrong number of args (" (jolt-dec (jolt-count items)) ") passed to: if")) jolt-nil) (let* ((_a$8788 (var-deref "jolt.ir" "if-node")) (_a$8789 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_a$8790 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 2) env)) (_a$8791 (if (> (jolt-count items) 3) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 3) env) (jolt-invoke (var-deref "jolt.ir" "const") jolt-nil)))) (jolt-invoke _a$8788 _a$8789 _a$8790 _a$8791))) (if (jolt= G__151 "do") (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-rest items) env) (if (jolt= G__151 "throw") (jolt-invoke (var-deref "jolt.ir" "throw-node") (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (if (jolt= G__151 "def") (jolt-invoke (var-deref "jolt.analyzer" "analyze-def") ctx items env) (if (jolt= G__151 "let*") (let* ((bvec (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 1)))) (r (jolt-invoke (var-deref "jolt.analyzer" "analyze-bindings") ctx bvec env))) (let* ((_a$8796 (var-deref "jolt.ir" "let-node")) (_a$8797 (jolt-first r)) (_a$8798 (let* ((_a$8792 (var-deref "jolt.analyzer" "analyze-seq")) (_a$8793 ctx) (_a$8794 (jolt-drop 2 items)) (_a$8795 (jolt-invoke (var-deref "clojure.core" "second") r))) (jolt-invoke _a$8792 _a$8793 _a$8794 _a$8795)))) (jolt-invoke _a$8796 _a$8797 _a$8798))) (if (jolt= G__151 "loop*") (let* ((bvec (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 1)))) (rname (jolt-invoke (var-deref "jolt.analyzer" "gen-name") "loop")) (r (jolt-invoke (var-deref "jolt.analyzer" "analyze-bindings") ctx bvec env)) (env** (jolt-invoke (var-deref "jolt.analyzer" "with-recur") (jolt-invoke (var-deref "clojure.core" "second") r) rname))) (let* ((_o$8799 (keyword #f "op")) (_o$8800 (keyword #f "loop")) (_o$8801 (keyword #f "recur-name")) (_o$8802 rname) (_o$8803 (keyword #f "bindings")) (_o$8804 (jolt-first r)) (_o$8805 (keyword #f "body")) (_o$8806 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env**))) (jolt-hash-map _o$8799 _o$8800 _o$8801 _o$8802 _o$8803 _o$8804 _o$8805 _o$8806))) (if (jolt= G__151 "recur") (let* ((rt (jolt-get env (keyword #f "recur")))) (begin (if (jolt-not rt) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "recur outside loop/fn") jolt-nil) (let* ((_o$8811 (keyword #f "op")) (_o$8812 (keyword #f "recur")) (_o$8813 (keyword #f "recur-name")) (_o$8814 rt) (_o$8815 (keyword #f "args")) (_o$8816 (let* ((_a$8808 (var-deref "clojure.core" "mapv")) (_a$8809 (lambda (p__99_) (let fnrec8807 ((p__99_ p__99_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__99_ env)))) (_a$8810 (jolt-rest items))) (jolt-invoke _a$8808 _a$8809 _a$8810)))) (jolt-hash-map _o$8811 _o$8812 _o$8813 _o$8814 _o$8815 _o$8816)))) (if (jolt= G__151 "try") (jolt-invoke (var-deref "jolt.analyzer" "analyze-try") ctx items env) (if (jolt= G__151 "letfn*") (jolt-invoke (var-deref "jolt.analyzer" "analyze-letfn*") ctx items env) (if (jolt= G__151 "fn*") (jolt-invoke (var-deref "jolt.analyzer" "analyze-fn") ctx items env) (if (jolt= G__151 "syntax-quote") (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-invoke (var-deref "jolt.host" "form-syntax-quote-lower") ctx (jolt-invoke (var-deref "clojure.core" "second") items)) env) (if (jolt= G__151 "var") (let* ((sym (jolt-invoke (var-deref "clojure.core" "second") items)) (r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx sym))) (if (jolt= (keyword #f "var") (jolt-get r (keyword #f "kind"))) (let* ((_a$8817 (var-deref "jolt.ir" "the-var")) (_a$8818 (jolt-get r (keyword #f "ns"))) (_a$8819 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8817 _a$8818 _a$8819)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "var of non-var " (jolt-invoke (var-deref "jolt.host" "form-sym-name") sym))))) (if (jolt= G__151 "defmacro") (let* ((name-sym (jolt-nth items 1)) (nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") name-sym)) (cur (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (after (jolt-drop 2 items)) (after (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") (jolt-first after))) (jolt-rest after) after)) (after (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-map?") (jolt-first after))) (jolt-rest after) after)) (fn-form (jolt-cons (jolt-invoke (var-deref "clojure.core" "symbol") "fn") after))) (begin (jolt-invoke (var-deref "jolt.host" "host-intern!") ctx cur nm) (let* ((_o$8820 (keyword #f "op")) (_o$8821 (keyword #f "defmacro")) (_o$8822 (keyword #f "ns")) (_o$8823 cur) (_o$8824 (keyword #f "name")) (_o$8825 nm) (_o$8826 (keyword #f "fn")) (_o$8827 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx fn-form env))) (jolt-hash-map _o$8820 _o$8821 _o$8822 _o$8823 _o$8824 _o$8825 _o$8826 _o$8827)))) (if (jolt= G__151 "set!") (jolt-invoke (var-deref "jolt.analyzer" "analyze-set!") ctx items env) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "special form " op)))))))))))))))))))))) analyze-special) (let* ((_o$8828 (keyword #f "private")) (_o$8829 #t)) (jolt-hash-map _o$8828 _o$8829)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "method-head?" (letrec ((method-head? (lambda (nm) (let fnrec8795 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 1))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 0 1)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt= "-" (jolt-invoke (var-deref "clojure.core" "subs") nm 1 2))))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 1 2))) and__25__auto)) and__25__auto)) and__25__auto)))))) method-head?) (let* ((_o$8796 (keyword #f "private")) (_o$8797 #t)) (jolt-hash-map _o$8796 _o$8797)))) + (def-var-with-meta! "jolt.analyzer" "method-head?" (letrec ((method-head? (lambda (nm) (let fnrec8830 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 1))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 0 1)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt= "-" (jolt-invoke (var-deref "clojure.core" "subs") nm 1 2))))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 1 2))) and__25__auto)) and__25__auto)) and__25__auto)))))) method-head?) (let* ((_o$8831 (keyword #f "private")) (_o$8832 #t)) (jolt-hash-map _o$8831 _o$8832)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-host-call" (letrec ((analyze-host-call (lambda (ctx hname items env) (let fnrec8798 ((ctx ctx) (hname hname) (items items) (env env)) (begin (if (< (jolt-count items) 2) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed member expression, expecting (.method target ...): " hname)) jolt-nil) (let* ((_o$8803 (keyword #f "op")) (_o$8804 (keyword #f "host-call")) (_o$8805 (keyword #f "method")) (_o$8806 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$8807 (keyword #f "target")) (_o$8808 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$8809 (keyword #f "args")) (_o$8810 (let* ((_a$8800 (var-deref "clojure.core" "mapv")) (_a$8801 (lambda (p__93_) (let fnrec8799 ((p__93_ p__93_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__93_ env)))) (_a$8802 (jolt-drop 2 items))) (jolt-invoke _a$8800 _a$8801 _a$8802)))) (jolt-hash-map _o$8803 _o$8804 _o$8805 _o$8806 _o$8807 _o$8808 _o$8809 _o$8810))))))) analyze-host-call) (let* ((_o$8811 (keyword #f "private")) (_o$8812 #t)) (jolt-hash-map _o$8811 _o$8812)))) + (def-var-with-meta! "jolt.analyzer" "analyze-host-call" (letrec ((analyze-host-call (lambda (ctx hname items env) (let fnrec8833 ((ctx ctx) (hname hname) (items items) (env env)) (begin (if (< (jolt-count items) 2) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed member expression, expecting (.method target ...): " hname)) jolt-nil) (let* ((_o$8838 (keyword #f "op")) (_o$8839 (keyword #f "host-call")) (_o$8840 (keyword #f "method")) (_o$8841 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$8842 (keyword #f "target")) (_o$8843 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$8844 (keyword #f "args")) (_o$8845 (let* ((_a$8835 (var-deref "clojure.core" "mapv")) (_a$8836 (lambda (p__100_) (let fnrec8834 ((p__100_ p__100_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__100_ env)))) (_a$8837 (jolt-drop 2 items))) (jolt-invoke _a$8835 _a$8836 _a$8837)))) (jolt-hash-map _o$8838 _o$8839 _o$8840 _o$8841 _o$8842 _o$8843 _o$8844 _o$8845))))))) analyze-host-call) (let* ((_o$8846 (keyword #f "private")) (_o$8847 #t)) (jolt-hash-map _o$8846 _o$8847)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "ctor-head?" (letrec ((ctor-head? (lambda (nm) (let fnrec8813 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 1))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "." (let* ((_a$8814 (var-deref "clojure.core" "subs")) (_a$8815 nm) (_a$8816 (jolt-dec (jolt-count nm))) (_a$8817 (jolt-count nm))) (jolt-invoke _a$8814 _a$8815 _a$8816 _a$8817))))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 0 1))) and__25__auto)) and__25__auto)))))) ctor-head?) (let* ((_o$8818 (keyword #f "private")) (_o$8819 #t)) (jolt-hash-map _o$8818 _o$8819)))) + (def-var-with-meta! "jolt.analyzer" "ctor-head?" (letrec ((ctor-head? (lambda (nm) (let fnrec8848 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 1))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "." (let* ((_a$8849 (var-deref "clojure.core" "subs")) (_a$8850 nm) (_a$8851 (jolt-dec (jolt-count nm))) (_a$8852 (jolt-count nm))) (jolt-invoke _a$8849 _a$8850 _a$8851 _a$8852))))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 0 1))) and__25__auto)) and__25__auto)))))) ctor-head?) (let* ((_o$8853 (keyword #f "private")) (_o$8854 #t)) (jolt-hash-map _o$8853 _o$8854)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-ctor" (letrec ((analyze-ctor (lambda (ctx class args env) (let fnrec8820 ((ctx ctx) (class class) (args args) (env env)) (jolt-invoke (var-deref "jolt.ir" "host-new") class (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__94_) (let fnrec8821 ((p__94_ p__94_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__94_ env))) args)))))) analyze-ctor) (let* ((_o$8822 (keyword #f "private")) (_o$8823 #t)) (jolt-hash-map _o$8822 _o$8823)))) + (def-var-with-meta! "jolt.analyzer" "analyze-ctor" (letrec ((analyze-ctor (lambda (ctx class args env) (let fnrec8855 ((ctx ctx) (class class) (args args) (env env)) (jolt-invoke (var-deref "jolt.ir" "host-new") class (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__101_) (let fnrec8856 ((p__101_ p__101_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__101_ env))) args)))))) analyze-ctor) (let* ((_o$8857 (keyword #f "private")) (_o$8858 #t)) (jolt-hash-map _o$8857 _o$8858)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-ffi-fn" (letrec ((analyze-ffi-fn (lambda (ctx items env) (let fnrec8824 ((ctx ctx) (items items) (env env)) (begin (if (jolt-not (<= 4 (jolt-count items) 5)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi/foreign-fn expects (foreign-fn \"sym\" [argtypes] rettype [:blocking])")) jolt-nil) (let* ((_o$8825 (keyword #f "op")) (_o$8826 (keyword #f "ffi-fn")) (_o$8827 (keyword #f "csym")) (_o$8828 (jolt-nth items 1)) (_o$8829 (keyword #f "argtypes")) (_o$8830 (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "clojure.core" "name") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 2)))) (_o$8831 (keyword #f "rettype")) (_o$8832 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$8833 (keyword #f "blocking")) (_o$8834 (let* ((and__25__auto (jolt= 5 (jolt-count items)))) (if (jolt-truthy? and__25__auto) (jolt= "blocking" (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 4))) and__25__auto)))) (jolt-hash-map _o$8825 _o$8826 _o$8827 _o$8828 _o$8829 _o$8830 _o$8831 _o$8832 _o$8833 _o$8834))))))) analyze-ffi-fn) (let* ((_o$8835 (keyword #f "private")) (_o$8836 #t)) (jolt-hash-map _o$8835 _o$8836)))) + (def-var-with-meta! "jolt.analyzer" "analyze-ffi-fn" (letrec ((analyze-ffi-fn (lambda (ctx items env) (let fnrec8859 ((ctx ctx) (items items) (env env)) (begin (if (jolt-not (<= 4 (jolt-count items) 5)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi/foreign-fn expects (foreign-fn \"sym\" [argtypes] rettype [:blocking])")) jolt-nil) (let* ((_o$8860 (keyword #f "op")) (_o$8861 (keyword #f "ffi-fn")) (_o$8862 (keyword #f "csym")) (_o$8863 (jolt-nth items 1)) (_o$8864 (keyword #f "argtypes")) (_o$8865 (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "clojure.core" "name") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 2)))) (_o$8866 (keyword #f "rettype")) (_o$8867 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$8868 (keyword #f "blocking")) (_o$8869 (let* ((and__25__auto (jolt= 5 (jolt-count items)))) (if (jolt-truthy? and__25__auto) (jolt= "blocking" (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 4))) and__25__auto)))) (jolt-hash-map _o$8860 _o$8861 _o$8862 _o$8863 _o$8864 _o$8865 _o$8866 _o$8867 _o$8868 _o$8869))))))) analyze-ffi-fn) (let* ((_o$8870 (keyword #f "private")) (_o$8871 #t)) (jolt-hash-map _o$8870 _o$8871)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-ffi-callable" (letrec ((analyze-ffi-callable (lambda (ctx items env) (let fnrec8837 ((ctx ctx) (items items) (env env)) (begin (if (jolt-not (<= 4 (jolt-count items) 5)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi/foreign-callable expects (foreign-callable f [argtypes] rettype [:collect-safe])")) jolt-nil) (let* ((_o$8838 (keyword #f "op")) (_o$8839 (keyword #f "ffi-callable")) (_o$8840 (keyword #f "fn")) (_o$8841 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$8842 (keyword #f "argtypes")) (_o$8843 (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "clojure.core" "name") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 2)))) (_o$8844 (keyword #f "rettype")) (_o$8845 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$8846 (keyword #f "collect-safe")) (_o$8847 (let* ((and__25__auto (jolt= 5 (jolt-count items)))) (if (jolt-truthy? and__25__auto) (jolt= "collect-safe" (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 4))) and__25__auto)))) (jolt-hash-map _o$8838 _o$8839 _o$8840 _o$8841 _o$8842 _o$8843 _o$8844 _o$8845 _o$8846 _o$8847))))))) analyze-ffi-callable) (let* ((_o$8848 (keyword #f "private")) (_o$8849 #t)) (jolt-hash-map _o$8848 _o$8849)))) + (def-var-with-meta! "jolt.analyzer" "analyze-ffi-callable" (letrec ((analyze-ffi-callable (lambda (ctx items env) (let fnrec8872 ((ctx ctx) (items items) (env env)) (begin (if (jolt-not (<= 4 (jolt-count items) 5)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi/foreign-callable expects (foreign-callable f [argtypes] rettype [:collect-safe])")) jolt-nil) (let* ((_o$8873 (keyword #f "op")) (_o$8874 (keyword #f "ffi-callable")) (_o$8875 (keyword #f "fn")) (_o$8876 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$8877 (keyword #f "argtypes")) (_o$8878 (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "clojure.core" "name") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 2)))) (_o$8879 (keyword #f "rettype")) (_o$8880 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$8881 (keyword #f "collect-safe")) (_o$8882 (let* ((and__25__auto (jolt= 5 (jolt-count items)))) (if (jolt-truthy? and__25__auto) (jolt= "collect-safe" (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 4))) and__25__auto)))) (jolt-hash-map _o$8873 _o$8874 _o$8875 _o$8876 _o$8877 _o$8878 _o$8879 _o$8880 _o$8881 _o$8882))))))) analyze-ffi-callable) (let* ((_o$8883 (keyword #f "private")) (_o$8884 #t)) (jolt-hash-map _o$8883 _o$8884)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-dot" (letrec ((analyze-dot (lambda (ctx items env) (let fnrec8850 ((ctx ctx) (items items) (env env)) (begin (if (< (jolt-count items) 3) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed (. target member ...) form")) jolt-nil) (let* ((member0 (jolt-nth items 2)) (items (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") member0)) (let* ((ml (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") member0)))) (let* ((_a$8854 (let* ((_o$8851 (jolt-nth items 0)) (_o$8852 (jolt-nth items 1)) (_o$8853 (jolt-first ml))) (jolt-vector _o$8851 _o$8852 _o$8853))) (_a$8855 (jolt-rest ml))) (jolt-into _a$8854 _a$8855))) items)) (target (jolt-nth items 1)) (member (jolt-nth items 2)) (class-target (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") target))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "jolt.analyzer" "local?") env (jolt-invoke (var-deref "jolt.host" "form-sym-name") target))) and__25__auto))) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx target))) (if (jolt= (keyword #f "class") (jolt-get r (keyword #f "kind"))) (jolt-get r (keyword #f "name")) jolt-nil)) jolt-nil))) (if (jolt-truthy? (let* ((and__25__auto class-target)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") member) and__25__auto))) (let* ((_a$8860 (var-deref "jolt.ir" "invoke")) (_a$8861 (jolt-invoke (var-deref "jolt.ir" "host-static") class-target (jolt-invoke (var-deref "jolt.host" "form-sym-name") member))) (_a$8862 (let* ((_a$8857 (var-deref "clojure.core" "mapv")) (_a$8858 (lambda (p__95_) (let fnrec8856 ((p__95_ p__95_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__95_ env)))) (_a$8859 (jolt-drop 3 items))) (jolt-invoke _a$8857 _a$8858 _a$8859)))) (jolt-invoke _a$8860 _a$8861 _a$8862)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") member)) (let* ((_o$8867 (keyword #f "op")) (_o$8868 (keyword #f "host-call")) (_o$8869 (keyword #f "method")) (_o$8870 (jolt-invoke (var-deref "jolt.host" "form-sym-name") member)) (_o$8871 (keyword #f "target")) (_o$8872 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx target env)) (_o$8873 (keyword #f "args")) (_o$8874 (let* ((_a$8864 (var-deref "clojure.core" "mapv")) (_a$8865 (lambda (p__96_) (let fnrec8863 ((p__96_ p__96_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__96_ env)))) (_a$8866 (jolt-drop 3 items))) (jolt-invoke _a$8864 _a$8865 _a$8866)))) (jolt-hash-map _o$8867 _o$8868 _o$8869 _o$8870 _o$8871 _o$8872 _o$8873 _o$8874)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-keyword?") member)) (let* ((_a$8875 (var-deref "jolt.ir" "invoke")) (_a$8876 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx member env)) (_a$8877 (jolt-vector (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)))) (jolt-invoke _a$8875 _a$8876 _a$8877)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "special form . (non-symbol member)") jolt-nil)))))))))) analyze-dot) (let* ((_o$8878 (keyword #f "private")) (_o$8879 #t)) (jolt-hash-map _o$8878 _o$8879)))) + (def-var-with-meta! "jolt.analyzer" "analyze-dot" (letrec ((analyze-dot (lambda (ctx items env) (let fnrec8885 ((ctx ctx) (items items) (env env)) (begin (if (< (jolt-count items) 3) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed (. target member ...) form")) jolt-nil) (let* ((member0 (jolt-nth items 2)) (items (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") member0)) (let* ((ml (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") member0)))) (let* ((_a$8889 (let* ((_o$8886 (jolt-nth items 0)) (_o$8887 (jolt-nth items 1)) (_o$8888 (jolt-first ml))) (jolt-vector _o$8886 _o$8887 _o$8888))) (_a$8890 (jolt-rest ml))) (jolt-into _a$8889 _a$8890))) items)) (target (jolt-nth items 1)) (member (jolt-nth items 2)) (class-target (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") target))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "jolt.analyzer" "local?") env (jolt-invoke (var-deref "jolt.host" "form-sym-name") target))) and__25__auto))) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx target))) (if (jolt= (keyword #f "class") (jolt-get r (keyword #f "kind"))) (jolt-get r (keyword #f "name")) jolt-nil)) jolt-nil))) (if (jolt-truthy? (let* ((and__25__auto class-target)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") member) and__25__auto))) (let* ((_a$8895 (var-deref "jolt.ir" "invoke")) (_a$8896 (jolt-invoke (var-deref "jolt.ir" "host-static") class-target (jolt-invoke (var-deref "jolt.host" "form-sym-name") member))) (_a$8897 (let* ((_a$8892 (var-deref "clojure.core" "mapv")) (_a$8893 (lambda (p__102_) (let fnrec8891 ((p__102_ p__102_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__102_ env)))) (_a$8894 (jolt-drop 3 items))) (jolt-invoke _a$8892 _a$8893 _a$8894)))) (jolt-invoke _a$8895 _a$8896 _a$8897)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") member)) (let* ((_o$8902 (keyword #f "op")) (_o$8903 (keyword #f "host-call")) (_o$8904 (keyword #f "method")) (_o$8905 (jolt-invoke (var-deref "jolt.host" "form-sym-name") member)) (_o$8906 (keyword #f "target")) (_o$8907 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx target env)) (_o$8908 (keyword #f "args")) (_o$8909 (let* ((_a$8899 (var-deref "clojure.core" "mapv")) (_a$8900 (lambda (p__103_) (let fnrec8898 ((p__103_ p__103_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__103_ env)))) (_a$8901 (jolt-drop 3 items))) (jolt-invoke _a$8899 _a$8900 _a$8901)))) (jolt-hash-map _o$8902 _o$8903 _o$8904 _o$8905 _o$8906 _o$8907 _o$8908 _o$8909)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-keyword?") member)) (let* ((_a$8910 (var-deref "jolt.ir" "invoke")) (_a$8911 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx member env)) (_a$8912 (jolt-vector (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)))) (jolt-invoke _a$8910 _a$8911 _a$8912)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "special form . (non-symbol member)") jolt-nil)))))))))) analyze-dot) (let* ((_o$8913 (keyword #f "private")) (_o$8914 #t)) (jolt-hash-map _o$8913 _o$8914)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-field" (letrec ((analyze-field (lambda (ctx hname items env) (let fnrec8880 ((ctx ctx) (hname hname) (items items) (env env)) (begin (if (< (jolt-count items) 2) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed (.-field target) form")) jolt-nil) (let* ((_o$8881 (keyword #f "op")) (_o$8882 (keyword #f "host-call")) (_o$8883 (keyword #f "method")) (_o$8884 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$8885 (keyword #f "target")) (_o$8886 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$8887 (keyword #f "args")) (_o$8888 (jolt-vector))) (jolt-hash-map _o$8881 _o$8882 _o$8883 _o$8884 _o$8885 _o$8886 _o$8887 _o$8888))))))) analyze-field) (let* ((_o$8889 (keyword #f "private")) (_o$8890 #t)) (jolt-hash-map _o$8889 _o$8890)))) + (def-var-with-meta! "jolt.analyzer" "analyze-field" (letrec ((analyze-field (lambda (ctx hname items env) (let fnrec8915 ((ctx ctx) (hname hname) (items items) (env env)) (begin (if (< (jolt-count items) 2) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed (.-field target) form")) jolt-nil) (let* ((_o$8916 (keyword #f "op")) (_o$8917 (keyword #f "host-call")) (_o$8918 (keyword #f "method")) (_o$8919 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$8920 (keyword #f "target")) (_o$8921 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$8922 (keyword #f "args")) (_o$8923 (jolt-vector))) (jolt-hash-map _o$8916 _o$8917 _o$8918 _o$8919 _o$8920 _o$8921 _o$8922 _o$8923))))))) analyze-field) (let* ((_o$8924 (keyword #f "private")) (_o$8925 #t)) (jolt-hash-map _o$8924 _o$8925)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-symbol" (letrec ((analyze-symbol (lambda (ctx form env) (let fnrec8891 ((ctx ctx) (form form) (env env)) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") form)) (ns (jolt-invoke (var-deref "jolt.host" "form-sym-ns") form))) (if (jolt-truthy? (let* ((and__25__auto (jolt-nil? ns))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "local?") env nm) and__25__auto))) (let* ((h (jolt-get (jolt-get env (keyword #f "hints")) nm))) (if (jolt-truthy? h) (jolt-assoc (jolt-invoke (var-deref "jolt.ir" "local") nm) (keyword #f "hint") h) (jolt-invoke (var-deref "jolt.ir" "local") nm))) (if (jolt-truthy? ns) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx form))) (if (jolt= (keyword #f "var") (jolt-get r (keyword #f "kind"))) (let* ((G__152 (let* ((_a$8892 (var-deref "jolt.ir" "var-ref")) (_a$8893 (jolt-get r (keyword #f "ns"))) (_a$8894 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8892 _a$8893 _a$8894)))) (let* ((G__153 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__152 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__152))) G__153)) (jolt-invoke (var-deref "jolt.ir" "host-static") ns nm))) (if (jolt-truthy? (keyword #f "else")) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx form))) (let* ((G__154 (jolt-get r (keyword #f "kind")))) (if (jolt= G__154 (keyword #f "var")) (let* ((G__155 (let* ((_a$8895 (var-deref "jolt.ir" "var-ref")) (_a$8896 (jolt-get r (keyword #f "ns"))) (_a$8897 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8895 _a$8896 _a$8897)))) (let* ((G__156 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__155 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__155))) G__156)) (if (jolt= G__154 (keyword #f "host")) (jolt-invoke (var-deref "jolt.ir" "host-ref") (jolt-get r (keyword #f "name"))) (if (jolt= G__154 (keyword #f "class")) (jolt-invoke (var-deref "jolt.ir" "const") (jolt-get r (keyword #f "name"))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "late-bind?") ctx)) (jolt-invoke (var-deref "jolt.ir" "var-ref") (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx) nm) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "Unable to resolve symbol: " nm " in this context")))))))) jolt-nil)))))))) analyze-symbol) (let* ((_o$8898 (keyword #f "private")) (_o$8899 #t)) (jolt-hash-map _o$8898 _o$8899)))) + (def-var-with-meta! "jolt.analyzer" "analyze-symbol" (letrec ((analyze-symbol (lambda (ctx form env) (let fnrec8926 ((ctx ctx) (form form) (env env)) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") form)) (ns (jolt-invoke (var-deref "jolt.host" "form-sym-ns") form))) (if (jolt-truthy? (let* ((and__25__auto (jolt-nil? ns))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "local?") env nm) and__25__auto))) (let* ((h (jolt-get (jolt-get env (keyword #f "hints")) nm))) (if (jolt-truthy? h) (jolt-assoc (jolt-invoke (var-deref "jolt.ir" "local") nm) (keyword #f "hint") h) (jolt-invoke (var-deref "jolt.ir" "local") nm))) (if (jolt-truthy? ns) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx form))) (if (jolt= (keyword #f "var") (jolt-get r (keyword #f "kind"))) (let* ((G__152 (let* ((_a$8927 (var-deref "jolt.ir" "var-ref")) (_a$8928 (jolt-get r (keyword #f "ns"))) (_a$8929 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8927 _a$8928 _a$8929)))) (let* ((G__153 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__152 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__152))) G__153)) (jolt-invoke (var-deref "jolt.ir" "host-static") ns nm))) (if (jolt-truthy? (keyword #f "else")) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx form))) (let* ((G__154 (jolt-get r (keyword #f "kind")))) (if (jolt= G__154 (keyword #f "var")) (let* ((G__155 (let* ((_a$8930 (var-deref "jolt.ir" "var-ref")) (_a$8931 (jolt-get r (keyword #f "ns"))) (_a$8932 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8930 _a$8931 _a$8932)))) (let* ((G__156 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__155 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__155))) G__156)) (if (jolt= G__154 (keyword #f "host")) (jolt-invoke (var-deref "jolt.ir" "host-ref") (jolt-get r (keyword #f "name"))) (if (jolt= G__154 (keyword #f "class")) (jolt-invoke (var-deref "jolt.ir" "const") (jolt-get r (keyword #f "name"))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "late-bind?") ctx)) (jolt-invoke (var-deref "jolt.ir" "var-ref") (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx) nm) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "Unable to resolve symbol: " nm " in this context")))))))) jolt-nil)))))))) analyze-symbol) (let* ((_o$8933 (keyword #f "private")) (_o$8934 #t)) (jolt-hash-map _o$8933 _o$8934)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "unchecked-arith" (letrec ((unchecked-arith (lambda (hname n) (let fnrec8900 ((hname hname) (n n)) (if (jolt= hname "+") "unchecked-add" (if (jolt= hname "*") "unchecked-multiply" (if (jolt= hname "-") (if (jolt= n 2) "unchecked-negate" "unchecked-subtract") (if (jolt= hname "inc") "unchecked-inc" (if (jolt= hname "dec") "unchecked-dec" (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))))))))) unchecked-arith) (let* ((_o$8901 (keyword #f "private")) (_o$8902 #t)) (jolt-hash-map _o$8901 _o$8902)))) + (def-var-with-meta! "jolt.analyzer" "unchecked-arith" (letrec ((unchecked-arith (lambda (hname n) (let fnrec8935 ((hname hname) (n n)) (if (jolt= hname "+") "unchecked-add" (if (jolt= hname "*") "unchecked-multiply" (if (jolt= hname "-") (if (jolt= n 2) "unchecked-negate" "unchecked-subtract") (if (jolt= hname "inc") "unchecked-inc" (if (jolt= hname "dec") "unchecked-dec" (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))))))))) unchecked-arith) (let* ((_o$8936 (keyword #f "private")) (_o$8937 #t)) (jolt-hash-map _o$8936 _o$8937)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-list" (letrec ((analyze-list (lambda (ctx form env) (let fnrec8903 ((ctx ctx) (form form) (env env)) (let* ((items (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") form)))) (if (jolt-zero? (jolt-count items)) (jolt-invoke (var-deref "jolt.ir" "quote-node") form) (let* ((head (jolt-first items)) (hname (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (jolt-nil? (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") head) jolt-nil)) (sf-name (let* ((or__26__auto hname)) (if (jolt-truthy? or__26__auto) or__26__auto (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "clojure.core" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)))) (if (jolt-truthy? and__25__auto) (jolt-contains? (var-deref "jolt.analyzer" "handled") (jolt-invoke (var-deref "jolt.host" "form-sym-name") head)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") head) jolt-nil)))) (shadowed (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "local?") env hname) and__25__auto))) (unm (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "unchecked-math?"))) (let* ((opn (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (jolt-not shadowed) and__25__auto))) hname (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (jolt= "clojure.core" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") head) jolt-nil)))) (if (jolt-truthy? opn) (jolt-invoke (var-deref "jolt.analyzer" "unchecked-arith") opn (jolt-count items)) jolt-nil)) jolt-nil))) (if (jolt-truthy? unm) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (let* ((_a$8904 (jolt-invoke (var-deref "clojure.core" "symbol") unm)) (_a$8905 (jolt-rest items))) (jolt-cons _a$8904 _a$8905)) env) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-contains? (var-deref "jolt.analyzer" "handled") sf-name)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-macro?") ctx head) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((node (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-invoke (var-deref "jolt.host" "form-expand-1") ctx form (jolt-invoke (var-deref "jolt.analyzer" "amp-env-map") env)) env)) (p (jolt-invoke (var-deref "jolt.host" "form-position") form))) (if (jolt-truthy? (let* ((and__25__auto p)) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))) and__25__auto))) (jolt-assoc node (keyword #f "pos") p) node)) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "jolt.ffi" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)))) (if (jolt-truthy? and__25__auto) (jolt= "__cfn" (jolt-invoke (var-deref "jolt.host" "form-sym-name") head)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-ffi-fn") ctx items env) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "jolt.ffi" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)))) (if (jolt-truthy? and__25__auto) (jolt= "__ccallable" (jolt-invoke (var-deref "jolt.host" "form-sym-name") head)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-ffi-callable") ctx items env) (if (jolt-truthy? (let* ((and__25__auto sf-name)) (if (jolt-truthy? and__25__auto) (jolt-contains? (var-deref "jolt.analyzer" "handled") sf-name) and__25__auto))) (let* ((node (jolt-invoke (var-deref "jolt.analyzer" "analyze-special") ctx sf-name items env)) (p (jolt-invoke (var-deref "jolt.host" "form-position") form))) (if (jolt-truthy? (let* ((and__25__auto p)) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))) and__25__auto))) (jolt-assoc node (keyword #f "pos") p) node)) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "method-head?") hname) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-host-call") ctx hname items env) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "ctor-head?") hname) and__25__auto)) and__25__auto))) (let* ((_a$8906 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$8907 ctx) (_a$8908 (jolt-invoke (var-deref "clojure.core" "subs") hname 0 (jolt-dec (jolt-count hname)))) (_a$8909 (jolt-rest items)) (_a$8910 env)) (jolt-invoke _a$8906 _a$8907 _a$8908 _a$8909 _a$8910)) (if (jolt-truthy? (let* ((and__25__auto (jolt= hname "new"))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= (jolt-count items) 2))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth items 1)) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((_a$8911 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$8912 ctx) (_a$8913 (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth items 1))) (_a$8914 (jolt-drop 2 items)) (_a$8915 env)) (jolt-invoke _a$8911 _a$8912 _a$8913 _a$8914 _a$8915)) (if (let* ((and__25__auto (jolt= hname "."))) (if (jolt-truthy? and__25__auto) (jolt-not shadowed) and__25__auto)) (jolt-invoke (var-deref "jolt.analyzer" "analyze-dot") ctx items env) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "field-head?") hname) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-field") ctx hname items env) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-special?") hname) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "special form " hname)) (if (jolt-truthy? (keyword #f "else")) (let* ((n (let* ((_a$8920 (var-deref "jolt.ir" "invoke")) (_a$8921 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx head env)) (_a$8922 (let* ((_a$8917 (var-deref "clojure.core" "mapv")) (_a$8918 (lambda (p__97_) (let fnrec8916 ((p__97_ p__97_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__97_ env)))) (_a$8919 (jolt-rest items))) (jolt-invoke _a$8917 _a$8918 _a$8919)))) (jolt-invoke _a$8920 _a$8921 _a$8922))) (p (jolt-invoke (var-deref "jolt.host" "form-position") form))) (if (jolt-truthy? p) (jolt-assoc n (keyword #f "pos") p) n)) jolt-nil))))))))))))))))))) analyze-list) (let* ((_o$8923 (keyword #f "private")) (_o$8924 #t)) (jolt-hash-map _o$8923 _o$8924)))) + (def-var-with-meta! "jolt.analyzer" "analyze-list" (letrec ((analyze-list (lambda (ctx form env) (let fnrec8938 ((ctx ctx) (form form) (env env)) (let* ((items (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") form)))) (if (jolt-zero? (jolt-count items)) (jolt-invoke (var-deref "jolt.ir" "quote-node") form) (let* ((head (jolt-first items)) (hname (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (jolt-nil? (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") head) jolt-nil)) (sf-name (let* ((or__26__auto hname)) (if (jolt-truthy? or__26__auto) or__26__auto (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "clojure.core" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)))) (if (jolt-truthy? and__25__auto) (jolt-contains? (var-deref "jolt.analyzer" "handled") (jolt-invoke (var-deref "jolt.host" "form-sym-name") head)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") head) jolt-nil)))) (shadowed (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "local?") env hname) and__25__auto))) (unm (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "unchecked-math?"))) (let* ((opn (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (jolt-not shadowed) and__25__auto))) hname (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (jolt= "clojure.core" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") head) jolt-nil)))) (if (jolt-truthy? opn) (jolt-invoke (var-deref "jolt.analyzer" "unchecked-arith") opn (jolt-count items)) jolt-nil)) jolt-nil))) (if (jolt-truthy? unm) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (let* ((_a$8939 (jolt-invoke (var-deref "clojure.core" "symbol") unm)) (_a$8940 (jolt-rest items))) (jolt-cons _a$8939 _a$8940)) env) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-contains? (var-deref "jolt.analyzer" "handled") sf-name)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-macro?") ctx head) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((node (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-invoke (var-deref "jolt.host" "form-expand-1") ctx form (jolt-invoke (var-deref "jolt.analyzer" "amp-env-map") env)) env)) (p (jolt-invoke (var-deref "jolt.host" "form-position") form))) (if (jolt-truthy? (let* ((and__25__auto p)) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))) and__25__auto))) (jolt-assoc node (keyword #f "pos") p) node)) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "jolt.ffi" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)))) (if (jolt-truthy? and__25__auto) (jolt= "__cfn" (jolt-invoke (var-deref "jolt.host" "form-sym-name") head)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-ffi-fn") ctx items env) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "jolt.ffi" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)))) (if (jolt-truthy? and__25__auto) (jolt= "__ccallable" (jolt-invoke (var-deref "jolt.host" "form-sym-name") head)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-ffi-callable") ctx items env) (if (jolt-truthy? (let* ((and__25__auto sf-name)) (if (jolt-truthy? and__25__auto) (jolt-contains? (var-deref "jolt.analyzer" "handled") sf-name) and__25__auto))) (let* ((node (jolt-invoke (var-deref "jolt.analyzer" "analyze-special") ctx sf-name items env)) (p (jolt-invoke (var-deref "jolt.host" "form-position") form))) (if (jolt-truthy? (let* ((and__25__auto p)) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))) and__25__auto))) (jolt-assoc node (keyword #f "pos") p) node)) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "method-head?") hname) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-host-call") ctx hname items env) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "ctor-head?") hname) and__25__auto)) and__25__auto))) (let* ((_a$8941 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$8942 ctx) (_a$8943 (jolt-invoke (var-deref "clojure.core" "subs") hname 0 (jolt-dec (jolt-count hname)))) (_a$8944 (jolt-rest items)) (_a$8945 env)) (jolt-invoke _a$8941 _a$8942 _a$8943 _a$8944 _a$8945)) (if (jolt-truthy? (let* ((and__25__auto (jolt= hname "new"))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= (jolt-count items) 2))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth items 1)) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((_a$8946 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$8947 ctx) (_a$8948 (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth items 1))) (_a$8949 (jolt-drop 2 items)) (_a$8950 env)) (jolt-invoke _a$8946 _a$8947 _a$8948 _a$8949 _a$8950)) (if (let* ((and__25__auto (jolt= hname "."))) (if (jolt-truthy? and__25__auto) (jolt-not shadowed) and__25__auto)) (jolt-invoke (var-deref "jolt.analyzer" "analyze-dot") ctx items env) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "field-head?") hname) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-field") ctx hname items env) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-special?") hname) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "special form " hname)) (if (jolt-truthy? (keyword #f "else")) (let* ((n (let* ((_a$8955 (var-deref "jolt.ir" "invoke")) (_a$8956 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx head env)) (_a$8957 (let* ((_a$8952 (var-deref "clojure.core" "mapv")) (_a$8953 (lambda (p__104_) (let fnrec8951 ((p__104_ p__104_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__104_ env)))) (_a$8954 (jolt-rest items))) (jolt-invoke _a$8952 _a$8953 _a$8954)))) (jolt-invoke _a$8955 _a$8956 _a$8957))) (p (jolt-invoke (var-deref "jolt.host" "form-position") form))) (if (jolt-truthy? p) (jolt-assoc n (keyword #f "pos") p) n)) jolt-nil))))))))))))))))))) analyze-list) (let* ((_o$8958 (keyword #f "private")) (_o$8959 #t)) (jolt-hash-map _o$8958 _o$8959)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "with-coll-meta" (letrec ((with-coll-meta (lambda (ctx form env node) (let fnrec8925 ((ctx ctx) (form form) (env env) (node node)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-coll-meta") form))) (if (jolt-nil? m) node (let* ((_a$8928 (var-deref "jolt.ir" "invoke")) (_a$8929 (jolt-invoke (var-deref "jolt.ir" "var-ref") "clojure.core" "with-meta")) (_a$8930 (let* ((_o$8926 node) (_o$8927 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx m env))) (jolt-vector _o$8926 _o$8927)))) (jolt-invoke _a$8928 _a$8929 _a$8930)))))))) with-coll-meta) (let* ((_o$8931 (keyword #f "private")) (_o$8932 #t)) (jolt-hash-map _o$8931 _o$8932)))) + (def-var-with-meta! "jolt.analyzer" "with-coll-meta" (letrec ((with-coll-meta (lambda (ctx form env node) (let fnrec8960 ((ctx ctx) (form form) (env env) (node node)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-coll-meta") form))) (if (jolt-nil? m) node (let* ((_a$8963 (var-deref "jolt.ir" "invoke")) (_a$8964 (jolt-invoke (var-deref "jolt.ir" "var-ref") "clojure.core" "with-meta")) (_a$8965 (let* ((_o$8961 node) (_o$8962 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx m env))) (jolt-vector _o$8961 _o$8962)))) (jolt-invoke _a$8963 _a$8964 _a$8965)))))))) with-coll-meta) (let* ((_o$8966 (keyword #f "private")) (_o$8967 #t)) (jolt-hash-map _o$8966 _o$8967)))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze" (letrec ((analyze (case-lambda ((ctx form) (let fnrec8933 ((ctx ctx) (form form)) (analyze ctx form (jolt-invoke (var-deref "jolt.analyzer" "empty-env"))))) ((ctx form env) (let fnrec8934 ((ctx ctx) (form form) (env env)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-literal?") form)) (jolt-invoke (var-deref "jolt.ir" "const") form) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") form)) (jolt-invoke (var-deref "jolt.analyzer" "analyze-symbol") ctx form env) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-vec?") form)) (jolt-invoke (var-deref "jolt.analyzer" "with-coll-meta") ctx form env (jolt-invoke (var-deref "jolt.ir" "vector-node") (let* ((_a$8936 (var-deref "clojure.core" "mapv")) (_a$8937 (lambda (p__98_) (let fnrec8935 ((p__98_ p__98_)) (analyze ctx p__98_ env)))) (_a$8938 (jolt-invoke (var-deref "jolt.host" "form-vec-items") form))) (jolt-invoke _a$8936 _a$8937 _a$8938)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-map?") form)) (jolt-invoke (var-deref "jolt.analyzer" "with-coll-meta") ctx form env (jolt-invoke (var-deref "jolt.ir" "map-node") (let* ((_a$8942 (var-deref "clojure.core" "mapv")) (_a$8943 (lambda (p) (let fnrec8939 ((p p)) (let* ((_o$8940 (analyze ctx (jolt-first p) env)) (_o$8941 (analyze ctx (jolt-invoke (var-deref "clojure.core" "second") p) env))) (jolt-vector _o$8940 _o$8941))))) (_a$8944 (jolt-invoke (var-deref "jolt.host" "form-map-pairs") form))) (jolt-invoke _a$8942 _a$8943 _a$8944)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-set?") form)) (jolt-invoke (var-deref "jolt.analyzer" "with-coll-meta") ctx form env (jolt-invoke (var-deref "jolt.ir" "set-node") (let* ((_a$8946 (var-deref "clojure.core" "mapv")) (_a$8947 (lambda (p__99_) (let fnrec8945 ((p__99_ p__99_)) (analyze ctx p__99_ env)))) (_a$8948 (jolt-invoke (var-deref "jolt.host" "form-set-items") form))) (jolt-invoke _a$8946 _a$8947 _a$8948)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") form)) (jolt-invoke (var-deref "jolt.analyzer" "analyze-list") ctx form env) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-regex?") form)) (let* ((_o$8949 (keyword #f "op")) (_o$8950 (keyword #f "regex")) (_o$8951 (keyword #f "source")) (_o$8952 (jolt-invoke (var-deref "jolt.host" "form-regex-source") form))) (jolt-hash-map _o$8949 _o$8950 _o$8951 _o$8952)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-inst?") form)) (let* ((_o$8953 (keyword #f "op")) (_o$8954 (keyword #f "inst")) (_o$8955 (keyword #f "source")) (_o$8956 (jolt-invoke (var-deref "jolt.host" "form-inst-source") form))) (jolt-hash-map _o$8953 _o$8954 _o$8955 _o$8956)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-uuid?") form)) (let* ((_o$8957 (keyword #f "op")) (_o$8958 (keyword #f "uuid")) (_o$8959 (keyword #f "source")) (_o$8960 (jolt-invoke (var-deref "jolt.host" "form-uuid-source") form))) (jolt-hash-map _o$8957 _o$8958 _o$8959 _o$8960)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-bigdec?") form)) (let* ((_o$8961 (keyword #f "op")) (_o$8962 (keyword #f "bigdec")) (_o$8963 (keyword #f "source")) (_o$8964 (jolt-invoke (var-deref "jolt.host" "form-bigdec-source") form))) (jolt-hash-map _o$8961 _o$8962 _o$8963 _o$8964)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-ns-value?") form)) (let* ((_o$8965 (keyword #f "op")) (_o$8966 (keyword #f "the-ns")) (_o$8967 (keyword #f "name")) (_o$8968 (jolt-invoke (var-deref "jolt.host" "form-ns-value-name") form))) (jolt-hash-map _o$8965 _o$8966 _o$8967 _o$8968)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-var-value?") form)) (let* ((_a$8969 (var-deref "jolt.ir" "the-var")) (_a$8970 (jolt-invoke (var-deref "jolt.host" "form-var-value-ns") form)) (_a$8971 (jolt-invoke (var-deref "jolt.host" "form-var-value-name") form))) (jolt-invoke _a$8969 _a$8970 _a$8971)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "unsupported form") jolt-nil)))))))))))))))))) analyze))) + (def-var! "jolt.analyzer" "analyze" (letrec ((analyze (case-lambda ((ctx form) (let fnrec8968 ((ctx ctx) (form form)) (analyze ctx form (jolt-invoke (var-deref "jolt.analyzer" "empty-env"))))) ((ctx form env) (let fnrec8969 ((ctx ctx) (form form) (env env)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-literal?") form)) (jolt-invoke (var-deref "jolt.ir" "const") form) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") form)) (jolt-invoke (var-deref "jolt.analyzer" "analyze-symbol") ctx form env) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-vec?") form)) (jolt-invoke (var-deref "jolt.analyzer" "with-coll-meta") ctx form env (jolt-invoke (var-deref "jolt.ir" "vector-node") (let* ((_a$8971 (var-deref "clojure.core" "mapv")) (_a$8972 (lambda (p__105_) (let fnrec8970 ((p__105_ p__105_)) (analyze ctx p__105_ env)))) (_a$8973 (jolt-invoke (var-deref "jolt.host" "form-vec-items") form))) (jolt-invoke _a$8971 _a$8972 _a$8973)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-map?") form)) (jolt-invoke (var-deref "jolt.analyzer" "with-coll-meta") ctx form env (jolt-invoke (var-deref "jolt.ir" "map-node") (let* ((_a$8977 (var-deref "clojure.core" "mapv")) (_a$8978 (lambda (p) (let fnrec8974 ((p p)) (let* ((_o$8975 (analyze ctx (jolt-first p) env)) (_o$8976 (analyze ctx (jolt-invoke (var-deref "clojure.core" "second") p) env))) (jolt-vector _o$8975 _o$8976))))) (_a$8979 (jolt-invoke (var-deref "jolt.host" "form-map-pairs") form))) (jolt-invoke _a$8977 _a$8978 _a$8979)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-set?") form)) (jolt-invoke (var-deref "jolt.analyzer" "with-coll-meta") ctx form env (jolt-invoke (var-deref "jolt.ir" "set-node") (let* ((_a$8981 (var-deref "clojure.core" "mapv")) (_a$8982 (lambda (p__106_) (let fnrec8980 ((p__106_ p__106_)) (analyze ctx p__106_ env)))) (_a$8983 (jolt-invoke (var-deref "jolt.host" "form-set-items") form))) (jolt-invoke _a$8981 _a$8982 _a$8983)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") form)) (jolt-invoke (var-deref "jolt.analyzer" "analyze-list") ctx form env) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-regex?") form)) (let* ((_o$8984 (keyword #f "op")) (_o$8985 (keyword #f "regex")) (_o$8986 (keyword #f "source")) (_o$8987 (jolt-invoke (var-deref "jolt.host" "form-regex-source") form))) (jolt-hash-map _o$8984 _o$8985 _o$8986 _o$8987)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-inst?") form)) (let* ((_o$8988 (keyword #f "op")) (_o$8989 (keyword #f "inst")) (_o$8990 (keyword #f "source")) (_o$8991 (jolt-invoke (var-deref "jolt.host" "form-inst-source") form))) (jolt-hash-map _o$8988 _o$8989 _o$8990 _o$8991)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-uuid?") form)) (let* ((_o$8992 (keyword #f "op")) (_o$8993 (keyword #f "uuid")) (_o$8994 (keyword #f "source")) (_o$8995 (jolt-invoke (var-deref "jolt.host" "form-uuid-source") form))) (jolt-hash-map _o$8992 _o$8993 _o$8994 _o$8995)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-bigdec?") form)) (let* ((_o$8996 (keyword #f "op")) (_o$8997 (keyword #f "bigdec")) (_o$8998 (keyword #f "source")) (_o$8999 (jolt-invoke (var-deref "jolt.host" "form-bigdec-source") form))) (jolt-hash-map _o$8996 _o$8997 _o$8998 _o$8999)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-ns-value?") form)) (let* ((_o$9000 (keyword #f "op")) (_o$9001 (keyword #f "the-ns")) (_o$9002 (keyword #f "name")) (_o$9003 (jolt-invoke (var-deref "jolt.host" "form-ns-value-name") form))) (jolt-hash-map _o$9000 _o$9001 _o$9002 _o$9003)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-var-value?") form)) (let* ((_a$9004 (var-deref "jolt.ir" "the-var")) (_a$9005 (jolt-invoke (var-deref "jolt.host" "form-var-value-ns") form)) (_a$9006 (jolt-invoke (var-deref "jolt.host" "form-var-value-name") form))) (jolt-invoke _a$9004 _a$9005 _a$9006)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "unsupported form") jolt-nil)))))))))))))))))) analyze))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "native-ops" (let* ((_o$7160 "+") (_o$7161 "+") (_o$7162 "-") (_o$7163 "-") (_o$7164 "*") (_o$7165 "*") (_o$7166 "/") (_o$7167 "/") (_o$7168 "<") (_o$7169 "<") (_o$7170 ">") (_o$7171 ">") (_o$7172 "<=") (_o$7173 "<=") (_o$7174 ">=") (_o$7175 ">=") (_o$7176 "=") (_o$7177 "jolt=") (_o$7178 "inc") (_o$7179 "jolt-inc") (_o$7180 "dec") (_o$7181 "jolt-dec") (_o$7182 "not") (_o$7183 "jolt-not") (_o$7184 "min") (_o$7185 "min") (_o$7186 "max") (_o$7187 "max") (_o$7188 "mod") (_o$7189 "modulo") (_o$7190 "rem") (_o$7191 "remainder") (_o$7192 "quot") (_o$7193 "quotient") (_o$7194 "vector") (_o$7195 "jolt-vector") (_o$7196 "hash-map") (_o$7197 "jolt-hash-map-fn") (_o$7198 "hash-set") (_o$7199 "jolt-hash-set") (_o$7200 "conj") (_o$7201 "jolt-conj") (_o$7202 "get") (_o$7203 "jolt-get") (_o$7204 "nth") (_o$7205 "jolt-nth") (_o$7206 "count") (_o$7207 "jolt-count") (_o$7208 "assoc") (_o$7209 "jolt-assoc") (_o$7210 "dissoc") (_o$7211 "jolt-dissoc") (_o$7212 "contains?") (_o$7213 "jolt-contains?") (_o$7214 "empty?") (_o$7215 "jolt-empty?") (_o$7216 "peek") (_o$7217 "jolt-peek") (_o$7218 "pop") (_o$7219 "jolt-pop") (_o$7220 "first") (_o$7221 "jolt-first") (_o$7222 "rest") (_o$7223 "jolt-rest") (_o$7224 "next") (_o$7225 "jolt-next") (_o$7226 "seq") (_o$7227 "jolt-seq") (_o$7228 "cons") (_o$7229 "jolt-cons") (_o$7230 "list") (_o$7231 "jolt-list") (_o$7232 "reverse") (_o$7233 "jolt-reverse") (_o$7234 "last") (_o$7235 "jolt-last") (_o$7236 "map") (_o$7237 "jolt-map") (_o$7238 "filter") (_o$7239 "jolt-filter") (_o$7240 "remove") (_o$7241 "jolt-remove") (_o$7242 "reduce") (_o$7243 "jolt-reduce") (_o$7244 "into") (_o$7245 "jolt-into") (_o$7246 "concat") (_o$7247 "jolt-concat") (_o$7248 "apply") (_o$7249 "jolt-apply") (_o$7250 "range") (_o$7251 "jolt-range") (_o$7252 "take") (_o$7253 "jolt-take") (_o$7254 "drop") (_o$7255 "jolt-drop") (_o$7256 "keys") (_o$7257 "jolt-keys") (_o$7258 "vals") (_o$7259 "jolt-vals") (_o$7260 "even?") (_o$7261 "jolt-even?") (_o$7262 "odd?") (_o$7263 "jolt-odd?") (_o$7264 "pos?") (_o$7265 "jolt-pos?") (_o$7266 "neg?") (_o$7267 "jolt-neg?") (_o$7268 "zero?") (_o$7269 "jolt-zero?") (_o$7270 "identity") (_o$7271 "jolt-identity") (_o$7272 "nil?") (_o$7273 "jolt-nil?") (_o$7274 "some?") (_o$7275 "jolt-some?") (_o$7276 "ex-info") (_o$7277 "jolt-ex-info") (_o$7278 "protocol-dispatch1") (_o$7279 "protocol-dispatch1") (_o$7280 "protocol-dispatch2") (_o$7281 "protocol-dispatch2") (_o$7282 "protocol-dispatch3") (_o$7283 "protocol-dispatch3")) (jolt-hash-map _o$7160 _o$7161 _o$7162 _o$7163 _o$7164 _o$7165 _o$7166 _o$7167 _o$7168 _o$7169 _o$7170 _o$7171 _o$7172 _o$7173 _o$7174 _o$7175 _o$7176 _o$7177 _o$7178 _o$7179 _o$7180 _o$7181 _o$7182 _o$7183 _o$7184 _o$7185 _o$7186 _o$7187 _o$7188 _o$7189 _o$7190 _o$7191 _o$7192 _o$7193 _o$7194 _o$7195 _o$7196 _o$7197 _o$7198 _o$7199 _o$7200 _o$7201 _o$7202 _o$7203 _o$7204 _o$7205 _o$7206 _o$7207 _o$7208 _o$7209 _o$7210 _o$7211 _o$7212 _o$7213 _o$7214 _o$7215 _o$7216 _o$7217 _o$7218 _o$7219 _o$7220 _o$7221 _o$7222 _o$7223 _o$7224 _o$7225 _o$7226 _o$7227 _o$7228 _o$7229 _o$7230 _o$7231 _o$7232 _o$7233 _o$7234 _o$7235 _o$7236 _o$7237 _o$7238 _o$7239 _o$7240 _o$7241 _o$7242 _o$7243 _o$7244 _o$7245 _o$7246 _o$7247 _o$7248 _o$7249 _o$7250 _o$7251 _o$7252 _o$7253 _o$7254 _o$7255 _o$7256 _o$7257 _o$7258 _o$7259 _o$7260 _o$7261 _o$7262 _o$7263 _o$7264 _o$7265 _o$7266 _o$7267 _o$7268 _o$7269 _o$7270 _o$7271 _o$7272 _o$7273 _o$7274 _o$7275 _o$7276 _o$7277 _o$7278 _o$7279 _o$7280 _o$7281 _o$7282 _o$7283)) (let* ((_o$7284 (keyword #f "private")) (_o$7285 #t)) (jolt-hash-map _o$7284 _o$7285)))) + (def-var-with-meta! "jolt.backend-scheme" "native-ops" (let* ((_o$7160 "+") (_o$7161 "+") (_o$7162 "-") (_o$7163 "-") (_o$7164 "*") (_o$7165 "*") (_o$7166 "/") (_o$7167 "/") (_o$7168 "<") (_o$7169 "<") (_o$7170 ">") (_o$7171 ">") (_o$7172 "<=") (_o$7173 "<=") (_o$7174 ">=") (_o$7175 ">=") (_o$7176 "=") (_o$7177 "jolt=") (_o$7178 "inc") (_o$7179 "jolt-inc") (_o$7180 "dec") (_o$7181 "jolt-dec") (_o$7182 "not") (_o$7183 "jolt-not") (_o$7184 "min") (_o$7185 "min") (_o$7186 "max") (_o$7187 "max") (_o$7188 "mod") (_o$7189 "modulo") (_o$7190 "rem") (_o$7191 "remainder") (_o$7192 "quot") (_o$7193 "quotient") (_o$7194 "vector") (_o$7195 "jolt-vector") (_o$7196 "hash-map") (_o$7197 "jolt-hash-map-fn") (_o$7198 "hash-set") (_o$7199 "jolt-hash-set") (_o$7200 "conj") (_o$7201 "jolt-conj") (_o$7202 "get") (_o$7203 "jolt-get") (_o$7204 "nth") (_o$7205 "jolt-nth") (_o$7206 "count") (_o$7207 "jolt-count") (_o$7208 "assoc") (_o$7209 "jolt-assoc") (_o$7210 "dissoc") (_o$7211 "jolt-dissoc") (_o$7212 "contains?") (_o$7213 "jolt-contains?") (_o$7214 "empty?") (_o$7215 "jolt-empty?") (_o$7216 "peek") (_o$7217 "jolt-peek") (_o$7218 "pop") (_o$7219 "jolt-pop") (_o$7220 "first") (_o$7221 "jolt-first") (_o$7222 "rest") (_o$7223 "jolt-rest") (_o$7224 "next") (_o$7225 "jolt-next") (_o$7226 "seq") (_o$7227 "jolt-seq") (_o$7228 "cons") (_o$7229 "jolt-cons") (_o$7230 "list") (_o$7231 "jolt-list") (_o$7232 "reverse") (_o$7233 "jolt-reverse") (_o$7234 "last") (_o$7235 "jolt-last") (_o$7236 "map") (_o$7237 "jolt-map") (_o$7238 "filter") (_o$7239 "jolt-filter") (_o$7240 "remove") (_o$7241 "jolt-remove") (_o$7242 "reduce") (_o$7243 "jolt-reduce") (_o$7244 "into") (_o$7245 "jolt-into") (_o$7246 "concat") (_o$7247 "jolt-concat") (_o$7248 "apply") (_o$7249 "jolt-apply") (_o$7250 "range") (_o$7251 "jolt-range") (_o$7252 "take") (_o$7253 "jolt-take") (_o$7254 "drop") (_o$7255 "jolt-drop") (_o$7256 "keys") (_o$7257 "jolt-keys") (_o$7258 "vals") (_o$7259 "jolt-vals") (_o$7260 "even?") (_o$7261 "jolt-even?") (_o$7262 "odd?") (_o$7263 "jolt-odd?") (_o$7264 "pos?") (_o$7265 "jolt-pos?") (_o$7266 "neg?") (_o$7267 "jolt-neg?") (_o$7268 "zero?") (_o$7269 "jolt-zero?") (_o$7270 "identity") (_o$7271 "jolt-identity") (_o$7272 "nil?") (_o$7273 "jolt-nil?") (_o$7274 "some?") (_o$7275 "jolt-some?") (_o$7276 "ex-info") (_o$7277 "jolt-ex-info") (_o$7278 "bit-and") (_o$7279 "bitwise-and") (_o$7280 "bit-or") (_o$7281 "bitwise-ior") (_o$7282 "bit-xor") (_o$7283 "bitwise-xor") (_o$7284 "bit-not") (_o$7285 "bitwise-not") (_o$7286 "bit-shift-left") (_o$7287 "jolt-bit-shift-left") (_o$7288 "bit-shift-right") (_o$7289 "jolt-bit-shift-right") (_o$7290 "unsigned-bit-shift-right") (_o$7291 "jolt-unsigned-bit-shift-right") (_o$7292 "protocol-dispatch1") (_o$7293 "protocol-dispatch1") (_o$7294 "protocol-dispatch2") (_o$7295 "protocol-dispatch2") (_o$7296 "protocol-dispatch3") (_o$7297 "protocol-dispatch3")) (jolt-hash-map _o$7160 _o$7161 _o$7162 _o$7163 _o$7164 _o$7165 _o$7166 _o$7167 _o$7168 _o$7169 _o$7170 _o$7171 _o$7172 _o$7173 _o$7174 _o$7175 _o$7176 _o$7177 _o$7178 _o$7179 _o$7180 _o$7181 _o$7182 _o$7183 _o$7184 _o$7185 _o$7186 _o$7187 _o$7188 _o$7189 _o$7190 _o$7191 _o$7192 _o$7193 _o$7194 _o$7195 _o$7196 _o$7197 _o$7198 _o$7199 _o$7200 _o$7201 _o$7202 _o$7203 _o$7204 _o$7205 _o$7206 _o$7207 _o$7208 _o$7209 _o$7210 _o$7211 _o$7212 _o$7213 _o$7214 _o$7215 _o$7216 _o$7217 _o$7218 _o$7219 _o$7220 _o$7221 _o$7222 _o$7223 _o$7224 _o$7225 _o$7226 _o$7227 _o$7228 _o$7229 _o$7230 _o$7231 _o$7232 _o$7233 _o$7234 _o$7235 _o$7236 _o$7237 _o$7238 _o$7239 _o$7240 _o$7241 _o$7242 _o$7243 _o$7244 _o$7245 _o$7246 _o$7247 _o$7248 _o$7249 _o$7250 _o$7251 _o$7252 _o$7253 _o$7254 _o$7255 _o$7256 _o$7257 _o$7258 _o$7259 _o$7260 _o$7261 _o$7262 _o$7263 _o$7264 _o$7265 _o$7266 _o$7267 _o$7268 _o$7269 _o$7270 _o$7271 _o$7272 _o$7273 _o$7274 _o$7275 _o$7276 _o$7277 _o$7278 _o$7279 _o$7280 _o$7281 _o$7282 _o$7283 _o$7284 _o$7285 _o$7286 _o$7287 _o$7288 _o$7289 _o$7290 _o$7291 _o$7292 _o$7293 _o$7294 _o$7295 _o$7296 _o$7297)) (let* ((_o$7298 (keyword #f "private")) (_o$7299 #t)) (jolt-hash-map _o$7298 _o$7299)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "core-value-procs" (jolt-invoke (var-deref "clojure.core" "merge") (var-deref "jolt.backend-scheme" "native-ops") (let* ((_o$7286 "+") (_o$7287 "jolt-add") (_o$7288 "-") (_o$7289 "jolt-sub") (_o$7290 "*") (_o$7291 "jolt-mul") (_o$7292 "/") (_o$7293 "jolt-div") (_o$7294 "min") (_o$7295 "jolt-min") (_o$7296 "max") (_o$7297 "jolt-max")) (jolt-hash-map _o$7286 _o$7287 _o$7288 _o$7289 _o$7290 _o$7291 _o$7292 _o$7293 _o$7294 _o$7295 _o$7296 _o$7297))) (let* ((_o$7298 (keyword #f "private")) (_o$7299 #t)) (jolt-hash-map _o$7298 _o$7299)))) + (def-var-with-meta! "jolt.backend-scheme" "core-value-procs" (jolt-invoke (var-deref "clojure.core" "merge") (var-deref "jolt.backend-scheme" "native-ops") (let* ((_o$7300 "+") (_o$7301 "jolt-add") (_o$7302 "-") (_o$7303 "jolt-sub") (_o$7304 "*") (_o$7305 "jolt-mul") (_o$7306 "/") (_o$7307 "jolt-div") (_o$7308 "min") (_o$7309 "jolt-min") (_o$7310 "max") (_o$7311 "jolt-max")) (jolt-hash-map _o$7300 _o$7301 _o$7302 _o$7303 _o$7304 _o$7305 _o$7306 _o$7307 _o$7308 _o$7309 _o$7310 _o$7311))) (let* ((_o$7312 (keyword #f "private")) (_o$7313 #t)) (jolt-hash-map _o$7312 _o$7313)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "op-arity" (let* ((_o$7346 "inc") (_o$7347 (lambda (p__42_) (let fnrec7300 ((p__42_ p__42_)) (jolt= p__42_ 1)))) (_o$7348 "dec") (_o$7349 (lambda (p__43_) (let fnrec7301 ((p__43_ p__43_)) (jolt= p__43_ 1)))) (_o$7350 "not") (_o$7351 (lambda (p__44_) (let fnrec7302 ((p__44_ p__44_)) (jolt= p__44_ 1)))) (_o$7352 "count") (_o$7353 (lambda (p__45_) (let fnrec7303 ((p__45_ p__45_)) (jolt= p__45_ 1)))) (_o$7354 "empty?") (_o$7355 (lambda (p__46_) (let fnrec7304 ((p__46_ p__46_)) (jolt= p__46_ 1)))) (_o$7356 "peek") (_o$7357 (lambda (p__47_) (let fnrec7305 ((p__47_ p__47_)) (jolt= p__47_ 1)))) (_o$7358 "pop") (_o$7359 (lambda (p__48_) (let fnrec7306 ((p__48_ p__48_)) (jolt= p__48_ 1)))) (_o$7360 "mod") (_o$7361 (lambda (p__49_) (let fnrec7307 ((p__49_ p__49_)) (jolt= p__49_ 2)))) (_o$7362 "rem") (_o$7363 (lambda (p__50_) (let fnrec7308 ((p__50_ p__50_)) (jolt= p__50_ 2)))) (_o$7364 "quot") (_o$7365 (lambda (p__51_) (let fnrec7309 ((p__51_ p__51_)) (jolt= p__51_ 2)))) (_o$7366 "contains?") (_o$7367 (lambda (p__52_) (let fnrec7310 ((p__52_ p__52_)) (jolt= p__52_ 2)))) (_o$7368 "get") (_o$7369 (lambda (p__53_) (let fnrec7311 ((p__53_ p__53_)) (let* ((or__26__auto (jolt= p__53_ 2))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= p__53_ 3)))))) (_o$7370 "nth") (_o$7371 (lambda (p__54_) (let fnrec7312 ((p__54_ p__54_)) (let* ((or__26__auto (jolt= p__54_ 2))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= p__54_ 3)))))) (_o$7372 "assoc") (_o$7373 (lambda (p__55_) (let fnrec7313 ((p__55_ p__55_)) (let* ((and__25__auto (>= p__55_ 3))) (if (jolt-truthy? and__25__auto) (jolt-odd? p__55_) and__25__auto))))) (_o$7374 "dissoc") (_o$7375 (lambda (p__56_) (let fnrec7314 ((p__56_ p__56_)) (>= p__56_ 1)))) (_o$7376 "conj") (_o$7377 (lambda (p__57_) (let fnrec7315 ((p__57_ p__57_)) (>= p__57_ 1)))) (_o$7378 "first") (_o$7379 (lambda (p__58_) (let fnrec7316 ((p__58_ p__58_)) (jolt= p__58_ 1)))) (_o$7380 "rest") (_o$7381 (lambda (p__59_) (let fnrec7317 ((p__59_ p__59_)) (jolt= p__59_ 1)))) (_o$7382 "next") (_o$7383 (lambda (p__60_) (let fnrec7318 ((p__60_ p__60_)) (jolt= p__60_ 1)))) (_o$7384 "seq") (_o$7385 (lambda (p__61_) (let fnrec7319 ((p__61_ p__61_)) (jolt= p__61_ 1)))) (_o$7386 "reverse") (_o$7387 (lambda (p__62_) (let fnrec7320 ((p__62_ p__62_)) (jolt= p__62_ 1)))) (_o$7388 "last") (_o$7389 (lambda (p__63_) (let fnrec7321 ((p__63_ p__63_)) (jolt= p__63_ 1)))) (_o$7390 "keys") (_o$7391 (lambda (p__64_) (let fnrec7322 ((p__64_ p__64_)) (jolt= p__64_ 1)))) (_o$7392 "vals") (_o$7393 (lambda (p__65_) (let fnrec7323 ((p__65_ p__65_)) (jolt= p__65_ 1)))) (_o$7394 "even?") (_o$7395 (lambda (p__66_) (let fnrec7324 ((p__66_ p__66_)) (jolt= p__66_ 1)))) (_o$7396 "odd?") (_o$7397 (lambda (p__67_) (let fnrec7325 ((p__67_ p__67_)) (jolt= p__67_ 1)))) (_o$7398 "pos?") (_o$7399 (lambda (p__68_) (let fnrec7326 ((p__68_ p__68_)) (jolt= p__68_ 1)))) (_o$7400 "neg?") (_o$7401 (lambda (p__69_) (let fnrec7327 ((p__69_ p__69_)) (jolt= p__69_ 1)))) (_o$7402 "zero?") (_o$7403 (lambda (p__70_) (let fnrec7328 ((p__70_ p__70_)) (jolt= p__70_ 1)))) (_o$7404 "identity") (_o$7405 (lambda (p__71_) (let fnrec7329 ((p__71_ p__71_)) (jolt= p__71_ 1)))) (_o$7406 "nil?") (_o$7407 (lambda (p__72_) (let fnrec7330 ((p__72_ p__72_)) (jolt= p__72_ 1)))) (_o$7408 "some?") (_o$7409 (lambda (p__73_) (let fnrec7331 ((p__73_ p__73_)) (jolt= p__73_ 1)))) (_o$7410 "protocol-dispatch1") (_o$7411 (lambda (p__74_) (let fnrec7332 ((p__74_ p__74_)) (jolt= p__74_ 3)))) (_o$7412 "protocol-dispatch2") (_o$7413 (lambda (p__75_) (let fnrec7333 ((p__75_ p__75_)) (jolt= p__75_ 4)))) (_o$7414 "protocol-dispatch3") (_o$7415 (lambda (p__76_) (let fnrec7334 ((p__76_ p__76_)) (jolt= p__76_ 5)))) (_o$7416 "cons") (_o$7417 (lambda (p__77_) (let fnrec7335 ((p__77_ p__77_)) (jolt= p__77_ 2)))) (_o$7418 "filter") (_o$7419 (lambda (p__78_) (let fnrec7336 ((p__78_ p__78_)) (jolt= p__78_ 2)))) (_o$7420 "remove") (_o$7421 (lambda (p__79_) (let fnrec7337 ((p__79_ p__79_)) (jolt= p__79_ 2)))) (_o$7422 "into") (_o$7423 (lambda (p__80_) (let fnrec7338 ((p__80_ p__80_)) (jolt= p__80_ 2)))) (_o$7424 "take") (_o$7425 (lambda (p__81_) (let fnrec7339 ((p__81_ p__81_)) (jolt= p__81_ 2)))) (_o$7426 "drop") (_o$7427 (lambda (p__82_) (let fnrec7340 ((p__82_ p__82_)) (jolt= p__82_ 2)))) (_o$7428 "map") (_o$7429 (lambda (p__83_) (let fnrec7341 ((p__83_ p__83_)) (>= p__83_ 2)))) (_o$7430 "apply") (_o$7431 (lambda (p__84_) (let fnrec7342 ((p__84_ p__84_)) (>= p__84_ 2)))) (_o$7432 "reduce") (_o$7433 (lambda (p__85_) (let fnrec7343 ((p__85_ p__85_)) (let* ((or__26__auto (jolt= p__85_ 2))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= p__85_ 3)))))) (_o$7434 "range") (_o$7435 (lambda (p__86_) (let fnrec7344 ((p__86_ p__86_)) (let* ((and__25__auto (>= p__86_ 0))) (if (jolt-truthy? and__25__auto) (<= p__86_ 3) and__25__auto))))) (_o$7436 "ex-info") (_o$7437 (lambda (p__87_) (let fnrec7345 ((p__87_ p__87_)) (let* ((or__26__auto (jolt= p__87_ 2))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= p__87_ 3))))))) (jolt-hash-map _o$7346 _o$7347 _o$7348 _o$7349 _o$7350 _o$7351 _o$7352 _o$7353 _o$7354 _o$7355 _o$7356 _o$7357 _o$7358 _o$7359 _o$7360 _o$7361 _o$7362 _o$7363 _o$7364 _o$7365 _o$7366 _o$7367 _o$7368 _o$7369 _o$7370 _o$7371 _o$7372 _o$7373 _o$7374 _o$7375 _o$7376 _o$7377 _o$7378 _o$7379 _o$7380 _o$7381 _o$7382 _o$7383 _o$7384 _o$7385 _o$7386 _o$7387 _o$7388 _o$7389 _o$7390 _o$7391 _o$7392 _o$7393 _o$7394 _o$7395 _o$7396 _o$7397 _o$7398 _o$7399 _o$7400 _o$7401 _o$7402 _o$7403 _o$7404 _o$7405 _o$7406 _o$7407 _o$7408 _o$7409 _o$7410 _o$7411 _o$7412 _o$7413 _o$7414 _o$7415 _o$7416 _o$7417 _o$7418 _o$7419 _o$7420 _o$7421 _o$7422 _o$7423 _o$7424 _o$7425 _o$7426 _o$7427 _o$7428 _o$7429 _o$7430 _o$7431 _o$7432 _o$7433 _o$7434 _o$7435 _o$7436 _o$7437)) (let* ((_o$7438 (keyword #f "private")) (_o$7439 #t)) (jolt-hash-map _o$7438 _o$7439)))) + (def-var-with-meta! "jolt.backend-scheme" "op-arity" (let* ((_o$7367 "inc") (_o$7368 (lambda (p__42_) (let fnrec7314 ((p__42_ p__42_)) (jolt= p__42_ 1)))) (_o$7369 "dec") (_o$7370 (lambda (p__43_) (let fnrec7315 ((p__43_ p__43_)) (jolt= p__43_ 1)))) (_o$7371 "not") (_o$7372 (lambda (p__44_) (let fnrec7316 ((p__44_ p__44_)) (jolt= p__44_ 1)))) (_o$7373 "count") (_o$7374 (lambda (p__45_) (let fnrec7317 ((p__45_ p__45_)) (jolt= p__45_ 1)))) (_o$7375 "empty?") (_o$7376 (lambda (p__46_) (let fnrec7318 ((p__46_ p__46_)) (jolt= p__46_ 1)))) (_o$7377 "peek") (_o$7378 (lambda (p__47_) (let fnrec7319 ((p__47_ p__47_)) (jolt= p__47_ 1)))) (_o$7379 "pop") (_o$7380 (lambda (p__48_) (let fnrec7320 ((p__48_ p__48_)) (jolt= p__48_ 1)))) (_o$7381 "mod") (_o$7382 (lambda (p__49_) (let fnrec7321 ((p__49_ p__49_)) (jolt= p__49_ 2)))) (_o$7383 "rem") (_o$7384 (lambda (p__50_) (let fnrec7322 ((p__50_ p__50_)) (jolt= p__50_ 2)))) (_o$7385 "quot") (_o$7386 (lambda (p__51_) (let fnrec7323 ((p__51_ p__51_)) (jolt= p__51_ 2)))) (_o$7387 "contains?") (_o$7388 (lambda (p__52_) (let fnrec7324 ((p__52_ p__52_)) (jolt= p__52_ 2)))) (_o$7389 "get") (_o$7390 (lambda (p__53_) (let fnrec7325 ((p__53_ p__53_)) (let* ((or__26__auto (jolt= p__53_ 2))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= p__53_ 3)))))) (_o$7391 "nth") (_o$7392 (lambda (p__54_) (let fnrec7326 ((p__54_ p__54_)) (let* ((or__26__auto (jolt= p__54_ 2))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= p__54_ 3)))))) (_o$7393 "assoc") (_o$7394 (lambda (p__55_) (let fnrec7327 ((p__55_ p__55_)) (let* ((and__25__auto (>= p__55_ 3))) (if (jolt-truthy? and__25__auto) (jolt-odd? p__55_) and__25__auto))))) (_o$7395 "dissoc") (_o$7396 (lambda (p__56_) (let fnrec7328 ((p__56_ p__56_)) (>= p__56_ 1)))) (_o$7397 "conj") (_o$7398 (lambda (p__57_) (let fnrec7329 ((p__57_ p__57_)) (>= p__57_ 1)))) (_o$7399 "first") (_o$7400 (lambda (p__58_) (let fnrec7330 ((p__58_ p__58_)) (jolt= p__58_ 1)))) (_o$7401 "rest") (_o$7402 (lambda (p__59_) (let fnrec7331 ((p__59_ p__59_)) (jolt= p__59_ 1)))) (_o$7403 "next") (_o$7404 (lambda (p__60_) (let fnrec7332 ((p__60_ p__60_)) (jolt= p__60_ 1)))) (_o$7405 "seq") (_o$7406 (lambda (p__61_) (let fnrec7333 ((p__61_ p__61_)) (jolt= p__61_ 1)))) (_o$7407 "reverse") (_o$7408 (lambda (p__62_) (let fnrec7334 ((p__62_ p__62_)) (jolt= p__62_ 1)))) (_o$7409 "last") (_o$7410 (lambda (p__63_) (let fnrec7335 ((p__63_ p__63_)) (jolt= p__63_ 1)))) (_o$7411 "keys") (_o$7412 (lambda (p__64_) (let fnrec7336 ((p__64_ p__64_)) (jolt= p__64_ 1)))) (_o$7413 "vals") (_o$7414 (lambda (p__65_) (let fnrec7337 ((p__65_ p__65_)) (jolt= p__65_ 1)))) (_o$7415 "even?") (_o$7416 (lambda (p__66_) (let fnrec7338 ((p__66_ p__66_)) (jolt= p__66_ 1)))) (_o$7417 "odd?") (_o$7418 (lambda (p__67_) (let fnrec7339 ((p__67_ p__67_)) (jolt= p__67_ 1)))) (_o$7419 "pos?") (_o$7420 (lambda (p__68_) (let fnrec7340 ((p__68_ p__68_)) (jolt= p__68_ 1)))) (_o$7421 "neg?") (_o$7422 (lambda (p__69_) (let fnrec7341 ((p__69_ p__69_)) (jolt= p__69_ 1)))) (_o$7423 "zero?") (_o$7424 (lambda (p__70_) (let fnrec7342 ((p__70_ p__70_)) (jolt= p__70_ 1)))) (_o$7425 "identity") (_o$7426 (lambda (p__71_) (let fnrec7343 ((p__71_ p__71_)) (jolt= p__71_ 1)))) (_o$7427 "nil?") (_o$7428 (lambda (p__72_) (let fnrec7344 ((p__72_ p__72_)) (jolt= p__72_ 1)))) (_o$7429 "some?") (_o$7430 (lambda (p__73_) (let fnrec7345 ((p__73_ p__73_)) (jolt= p__73_ 1)))) (_o$7431 "protocol-dispatch1") (_o$7432 (lambda (p__74_) (let fnrec7346 ((p__74_ p__74_)) (jolt= p__74_ 3)))) (_o$7433 "protocol-dispatch2") (_o$7434 (lambda (p__75_) (let fnrec7347 ((p__75_ p__75_)) (jolt= p__75_ 4)))) (_o$7435 "protocol-dispatch3") (_o$7436 (lambda (p__76_) (let fnrec7348 ((p__76_ p__76_)) (jolt= p__76_ 5)))) (_o$7437 "cons") (_o$7438 (lambda (p__77_) (let fnrec7349 ((p__77_ p__77_)) (jolt= p__77_ 2)))) (_o$7439 "filter") (_o$7440 (lambda (p__78_) (let fnrec7350 ((p__78_ p__78_)) (jolt= p__78_ 2)))) (_o$7441 "remove") (_o$7442 (lambda (p__79_) (let fnrec7351 ((p__79_ p__79_)) (jolt= p__79_ 2)))) (_o$7443 "into") (_o$7444 (lambda (p__80_) (let fnrec7352 ((p__80_ p__80_)) (jolt= p__80_ 2)))) (_o$7445 "take") (_o$7446 (lambda (p__81_) (let fnrec7353 ((p__81_ p__81_)) (jolt= p__81_ 2)))) (_o$7447 "drop") (_o$7448 (lambda (p__82_) (let fnrec7354 ((p__82_ p__82_)) (jolt= p__82_ 2)))) (_o$7449 "map") (_o$7450 (lambda (p__83_) (let fnrec7355 ((p__83_ p__83_)) (>= p__83_ 2)))) (_o$7451 "apply") (_o$7452 (lambda (p__84_) (let fnrec7356 ((p__84_ p__84_)) (>= p__84_ 2)))) (_o$7453 "reduce") (_o$7454 (lambda (p__85_) (let fnrec7357 ((p__85_ p__85_)) (let* ((or__26__auto (jolt= p__85_ 2))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= p__85_ 3)))))) (_o$7455 "range") (_o$7456 (lambda (p__86_) (let fnrec7358 ((p__86_ p__86_)) (let* ((and__25__auto (>= p__86_ 0))) (if (jolt-truthy? and__25__auto) (<= p__86_ 3) and__25__auto))))) (_o$7457 "ex-info") (_o$7458 (lambda (p__87_) (let fnrec7359 ((p__87_ p__87_)) (let* ((or__26__auto (jolt= p__87_ 2))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= p__87_ 3)))))) (_o$7459 "bit-and") (_o$7460 (lambda (p__88_) (let fnrec7360 ((p__88_ p__88_)) (jolt= p__88_ 2)))) (_o$7461 "bit-or") (_o$7462 (lambda (p__89_) (let fnrec7361 ((p__89_ p__89_)) (jolt= p__89_ 2)))) (_o$7463 "bit-xor") (_o$7464 (lambda (p__90_) (let fnrec7362 ((p__90_ p__90_)) (jolt= p__90_ 2)))) (_o$7465 "bit-not") (_o$7466 (lambda (p__91_) (let fnrec7363 ((p__91_ p__91_)) (jolt= p__91_ 1)))) (_o$7467 "bit-shift-left") (_o$7468 (lambda (p__92_) (let fnrec7364 ((p__92_ p__92_)) (jolt= p__92_ 2)))) (_o$7469 "bit-shift-right") (_o$7470 (lambda (p__93_) (let fnrec7365 ((p__93_ p__93_)) (jolt= p__93_ 2)))) (_o$7471 "unsigned-bit-shift-right") (_o$7472 (lambda (p__94_) (let fnrec7366 ((p__94_ p__94_)) (jolt= p__94_ 2))))) (jolt-hash-map _o$7367 _o$7368 _o$7369 _o$7370 _o$7371 _o$7372 _o$7373 _o$7374 _o$7375 _o$7376 _o$7377 _o$7378 _o$7379 _o$7380 _o$7381 _o$7382 _o$7383 _o$7384 _o$7385 _o$7386 _o$7387 _o$7388 _o$7389 _o$7390 _o$7391 _o$7392 _o$7393 _o$7394 _o$7395 _o$7396 _o$7397 _o$7398 _o$7399 _o$7400 _o$7401 _o$7402 _o$7403 _o$7404 _o$7405 _o$7406 _o$7407 _o$7408 _o$7409 _o$7410 _o$7411 _o$7412 _o$7413 _o$7414 _o$7415 _o$7416 _o$7417 _o$7418 _o$7419 _o$7420 _o$7421 _o$7422 _o$7423 _o$7424 _o$7425 _o$7426 _o$7427 _o$7428 _o$7429 _o$7430 _o$7431 _o$7432 _o$7433 _o$7434 _o$7435 _o$7436 _o$7437 _o$7438 _o$7439 _o$7440 _o$7441 _o$7442 _o$7443 _o$7444 _o$7445 _o$7446 _o$7447 _o$7448 _o$7449 _o$7450 _o$7451 _o$7452 _o$7453 _o$7454 _o$7455 _o$7456 _o$7457 _o$7458 _o$7459 _o$7460 _o$7461 _o$7462 _o$7463 _o$7464 _o$7465 _o$7466 _o$7467 _o$7468 _o$7469 _o$7470 _o$7471 _o$7472)) (let* ((_o$7473 (keyword #f "private")) (_o$7474 #t)) (jolt-hash-map _o$7473 _o$7474)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "cmp1-ops" (let* ((_o$7440 "<") (_o$7441 ">") (_o$7442 "<=") (_o$7443 ">=")) (jolt-hash-set _o$7440 _o$7441 _o$7442 _o$7443)) (let* ((_o$7444 (keyword #f "private")) (_o$7445 #t)) (jolt-hash-map _o$7444 _o$7445)))) + (def-var-with-meta! "jolt.backend-scheme" "cmp1-ops" (let* ((_o$7475 "<") (_o$7476 ">") (_o$7477 "<=") (_o$7478 ">=")) (jolt-hash-set _o$7475 _o$7476 _o$7477 _o$7478)) (let* ((_o$7479 (keyword #f "private")) (_o$7480 #t)) (jolt-hash-map _o$7479 _o$7480)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "supported-host-methods" (let* ((_o$7446 "isDirectory") (_o$7447 "listFiles")) (jolt-hash-set _o$7446 _o$7447)) (let* ((_o$7448 (keyword #f "private")) (_o$7449 #t)) (jolt-hash-map _o$7448 _o$7449)))) + (def-var-with-meta! "jolt.backend-scheme" "supported-host-methods" (let* ((_o$7481 "isDirectory") (_o$7482 "listFiles")) (jolt-hash-set _o$7481 _o$7482)) (let* ((_o$7483 (keyword #f "private")) (_o$7484 #t)) (jolt-hash-map _o$7483 _o$7484)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "bool-returning-ops" (let* ((_o$7450 "<") (_o$7451 "<=") (_o$7452 ">") (_o$7453 ">=") (_o$7454 "jolt=") (_o$7455 "jolt-not") (_o$7456 "jolt-even?") (_o$7457 "jolt-odd?") (_o$7458 "jolt-pos?") (_o$7459 "jolt-neg?") (_o$7460 "jolt-zero?") (_o$7461 "jolt-empty?") (_o$7462 "jolt-contains?") (_o$7463 "jolt-nil?") (_o$7464 "jolt-some?")) (jolt-hash-set _o$7450 _o$7451 _o$7452 _o$7453 _o$7454 _o$7455 _o$7456 _o$7457 _o$7458 _o$7459 _o$7460 _o$7461 _o$7462 _o$7463 _o$7464)) (let* ((_o$7465 (keyword #f "private")) (_o$7466 #t)) (jolt-hash-map _o$7465 _o$7466)))) + (def-var-with-meta! "jolt.backend-scheme" "bool-returning-ops" (let* ((_o$7485 "<") (_o$7486 "<=") (_o$7487 ">") (_o$7488 ">=") (_o$7489 "jolt=") (_o$7490 "jolt-not") (_o$7491 "jolt-even?") (_o$7492 "jolt-odd?") (_o$7493 "jolt-pos?") (_o$7494 "jolt-neg?") (_o$7495 "jolt-zero?") (_o$7496 "jolt-empty?") (_o$7497 "jolt-contains?") (_o$7498 "jolt-nil?") (_o$7499 "jolt-some?")) (jolt-hash-set _o$7485 _o$7486 _o$7487 _o$7488 _o$7489 _o$7490 _o$7491 _o$7492 _o$7493 _o$7494 _o$7495 _o$7496 _o$7497 _o$7498 _o$7499)) (let* ((_o$7500 (keyword #f "private")) (_o$7501 #t)) (jolt-hash-map _o$7500 _o$7501)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "dbl-ops" (let* ((_o$7467 "+") (_o$7468 "fl+") (_o$7469 "-") (_o$7470 "fl-") (_o$7471 "*") (_o$7472 "fl*") (_o$7473 "/") (_o$7474 "fl/") (_o$7475 "min") (_o$7476 "flmin") (_o$7477 "max") (_o$7478 "flmax") (_o$7479 "<") (_o$7480 "fl") (_o$7482 "fl>?") (_o$7483 "<=") (_o$7484 "fl<=?") (_o$7485 ">=") (_o$7486 "fl>=?") (_o$7487 "=") (_o$7488 "fl=?") (_o$7489 "==") (_o$7490 "fl=?")) (jolt-hash-map _o$7467 _o$7468 _o$7469 _o$7470 _o$7471 _o$7472 _o$7473 _o$7474 _o$7475 _o$7476 _o$7477 _o$7478 _o$7479 _o$7480 _o$7481 _o$7482 _o$7483 _o$7484 _o$7485 _o$7486 _o$7487 _o$7488 _o$7489 _o$7490)) (let* ((_o$7491 (keyword #f "private")) (_o$7492 #t)) (jolt-hash-map _o$7491 _o$7492)))) + (def-var-with-meta! "jolt.backend-scheme" "dbl-ops" (let* ((_o$7502 "+") (_o$7503 "fl+") (_o$7504 "-") (_o$7505 "fl-") (_o$7506 "*") (_o$7507 "fl*") (_o$7508 "/") (_o$7509 "fl/") (_o$7510 "min") (_o$7511 "flmin") (_o$7512 "max") (_o$7513 "flmax") (_o$7514 "<") (_o$7515 "fl") (_o$7517 "fl>?") (_o$7518 "<=") (_o$7519 "fl<=?") (_o$7520 ">=") (_o$7521 "fl>=?") (_o$7522 "=") (_o$7523 "fl=?") (_o$7524 "==") (_o$7525 "fl=?")) (jolt-hash-map _o$7502 _o$7503 _o$7504 _o$7505 _o$7506 _o$7507 _o$7508 _o$7509 _o$7510 _o$7511 _o$7512 _o$7513 _o$7514 _o$7515 _o$7516 _o$7517 _o$7518 _o$7519 _o$7520 _o$7521 _o$7522 _o$7523 _o$7524 _o$7525)) (let* ((_o$7526 (keyword #f "private")) (_o$7527 #t)) (jolt-hash-map _o$7526 _o$7527)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "lng-ops" (let* ((_o$7493 "+") (_o$7494 "fx+") (_o$7495 "-") (_o$7496 "fx-") (_o$7497 "*") (_o$7498 "fx*") (_o$7499 "min") (_o$7500 "jolt-l-min") (_o$7501 "max") (_o$7502 "jolt-l-max") (_o$7503 "unchecked-add") (_o$7504 "jolt-uncadd2") (_o$7505 "unchecked-subtract") (_o$7506 "jolt-uncsub2") (_o$7507 "unchecked-multiply") (_o$7508 "jolt-uncmul2") (_o$7509 "quot") (_o$7510 "jolt-l-quot") (_o$7511 "rem") (_o$7512 "jolt-l-rem") (_o$7513 "mod") (_o$7514 "jolt-l-mod") (_o$7515 "<") (_o$7516 "jolt-l<") (_o$7517 ">") (_o$7518 "jolt-l>") (_o$7519 "<=") (_o$7520 "jolt-l<=") (_o$7521 ">=") (_o$7522 "jolt-l>=") (_o$7523 "=") (_o$7524 "jolt-l=") (_o$7525 "==") (_o$7526 "jolt-l=")) (jolt-hash-map _o$7493 _o$7494 _o$7495 _o$7496 _o$7497 _o$7498 _o$7499 _o$7500 _o$7501 _o$7502 _o$7503 _o$7504 _o$7505 _o$7506 _o$7507 _o$7508 _o$7509 _o$7510 _o$7511 _o$7512 _o$7513 _o$7514 _o$7515 _o$7516 _o$7517 _o$7518 _o$7519 _o$7520 _o$7521 _o$7522 _o$7523 _o$7524 _o$7525 _o$7526)) (let* ((_o$7527 (keyword #f "private")) (_o$7528 #t)) (jolt-hash-map _o$7527 _o$7528)))) + (def-var-with-meta! "jolt.backend-scheme" "lng-ops" (let* ((_o$7528 "+") (_o$7529 "fx+") (_o$7530 "-") (_o$7531 "fx-") (_o$7532 "*") (_o$7533 "fx*") (_o$7534 "min") (_o$7535 "jolt-l-min") (_o$7536 "max") (_o$7537 "jolt-l-max") (_o$7538 "unchecked-add") (_o$7539 "jolt-uncadd2") (_o$7540 "unchecked-subtract") (_o$7541 "jolt-uncsub2") (_o$7542 "unchecked-multiply") (_o$7543 "jolt-uncmul2") (_o$7544 "quot") (_o$7545 "jolt-l-quot") (_o$7546 "rem") (_o$7547 "jolt-l-rem") (_o$7548 "mod") (_o$7549 "jolt-l-mod") (_o$7550 "<") (_o$7551 "jolt-l<") (_o$7552 ">") (_o$7553 "jolt-l>") (_o$7554 "<=") (_o$7555 "jolt-l<=") (_o$7556 ">=") (_o$7557 "jolt-l>=") (_o$7558 "=") (_o$7559 "jolt-l=") (_o$7560 "==") (_o$7561 "jolt-l=")) (jolt-hash-map _o$7528 _o$7529 _o$7530 _o$7531 _o$7532 _o$7533 _o$7534 _o$7535 _o$7536 _o$7537 _o$7538 _o$7539 _o$7540 _o$7541 _o$7542 _o$7543 _o$7544 _o$7545 _o$7546 _o$7547 _o$7548 _o$7549 _o$7550 _o$7551 _o$7552 _o$7553 _o$7554 _o$7555 _o$7556 _o$7557 _o$7558 _o$7559 _o$7560 _o$7561)) (let* ((_o$7562 (keyword #f "private")) (_o$7563 #t)) (jolt-hash-map _o$7562 _o$7563)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "bd-ops" (let* ((_o$7529 "+") (_o$7530 "jbd-add") (_o$7531 "-") (_o$7532 "jbd-sub") (_o$7533 "*") (_o$7534 "jbd-mul") (_o$7535 "/") (_o$7536 "jbd-div") (_o$7537 "min") (_o$7538 "jbd-min") (_o$7539 "max") (_o$7540 "jbd-max") (_o$7541 "quot") (_o$7542 "jbd-quot") (_o$7543 "rem") (_o$7544 "jbd-rem") (_o$7545 "<") (_o$7546 "jbd-lt?") (_o$7547 ">") (_o$7548 "jbd-gt?") (_o$7549 "<=") (_o$7550 "jbd-le?") (_o$7551 ">=") (_o$7552 "jbd-ge?") (_o$7553 "zero?") (_o$7554 "jbd-zero?") (_o$7555 "pos?") (_o$7556 "jbd-pos?") (_o$7557 "neg?") (_o$7558 "jbd-neg?")) (jolt-hash-map _o$7529 _o$7530 _o$7531 _o$7532 _o$7533 _o$7534 _o$7535 _o$7536 _o$7537 _o$7538 _o$7539 _o$7540 _o$7541 _o$7542 _o$7543 _o$7544 _o$7545 _o$7546 _o$7547 _o$7548 _o$7549 _o$7550 _o$7551 _o$7552 _o$7553 _o$7554 _o$7555 _o$7556 _o$7557 _o$7558)) (let* ((_o$7559 (keyword #f "private")) (_o$7560 #t)) (jolt-hash-map _o$7559 _o$7560)))) + (def-var-with-meta! "jolt.backend-scheme" "bd-ops" (let* ((_o$7564 "+") (_o$7565 "jbd-add") (_o$7566 "-") (_o$7567 "jbd-sub") (_o$7568 "*") (_o$7569 "jbd-mul") (_o$7570 "/") (_o$7571 "jbd-div") (_o$7572 "min") (_o$7573 "jbd-min") (_o$7574 "max") (_o$7575 "jbd-max") (_o$7576 "quot") (_o$7577 "jbd-quot") (_o$7578 "rem") (_o$7579 "jbd-rem") (_o$7580 "<") (_o$7581 "jbd-lt?") (_o$7582 ">") (_o$7583 "jbd-gt?") (_o$7584 "<=") (_o$7585 "jbd-le?") (_o$7586 ">=") (_o$7587 "jbd-ge?") (_o$7588 "zero?") (_o$7589 "jbd-zero?") (_o$7590 "pos?") (_o$7591 "jbd-pos?") (_o$7592 "neg?") (_o$7593 "jbd-neg?")) (jolt-hash-map _o$7564 _o$7565 _o$7566 _o$7567 _o$7568 _o$7569 _o$7570 _o$7571 _o$7572 _o$7573 _o$7574 _o$7575 _o$7576 _o$7577 _o$7578 _o$7579 _o$7580 _o$7581 _o$7582 _o$7583 _o$7584 _o$7585 _o$7586 _o$7587 _o$7588 _o$7589 _o$7590 _o$7591 _o$7592 _o$7593)) (let* ((_o$7594 (keyword #f "private")) (_o$7595 #t)) (jolt-hash-map _o$7594 _o$7595)))) (guard (e (#t #f)) (def-var! "jolt.backend-scheme" "prelude-mode?" (jolt-invoke (var-deref "clojure.core" "atom") #f))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "set-prelude-mode!" (letrec ((set-prelude-mode! (lambda (on) (let fnrec7561 ((on on)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "prelude-mode?") on))))) set-prelude-mode!))) + (def-var! "jolt.backend-scheme" "set-prelude-mode!" (letrec ((set-prelude-mode! (lambda (on) (let fnrec7596 ((on on)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "prelude-mode?") on))))) set-prelude-mode!))) (guard (e (#t #f)) (def-var! "jolt.backend-scheme" "direct-link?" (jolt-invoke (var-deref "clojure.core" "atom") #f))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "set-direct-link!" (letrec ((set-direct-link! (lambda (on) (let fnrec7562 ((on on)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "direct-link?") on))))) set-direct-link!))) + (def-var! "jolt.backend-scheme" "set-direct-link!" (letrec ((set-direct-link! (lambda (on) (let fnrec7597 ((on on)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "direct-link?") on))))) set-direct-link!))) (guard (e (#t #f)) (def-var! "jolt.backend-scheme" "direct-link-defined" (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-set)))) (guard (e (#t #f)) (def-var! "jolt.backend-scheme" "direct-link-fns" (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-set)))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "direct-link-reset!" (letrec ((direct-link-reset! (lambda () (let fnrec7563 () (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "direct-link-defined") (jolt-hash-set)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "direct-link-fns") (jolt-hash-set))))))) direct-link-reset!))) + (def-var! "jolt.backend-scheme" "direct-link-reset!" (letrec ((direct-link-reset! (lambda () (let fnrec7598 () (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "direct-link-defined") (jolt-hash-set)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "direct-link-fns") (jolt-hash-set))))))) direct-link-reset!))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "dl-munge" (letrec ((dl-munge (lambda (s) (let fnrec7564 ((s s)) (jolt-invoke (var-deref "clojure.string" "replace") (jolt-invoke (var-deref "clojure.string" "replace") (jolt-invoke (var-deref "clojure.string" "replace") s "$" "_D_") "#" "_H_") "'" "_Q_"))))) dl-munge) (let* ((_o$7565 (keyword #f "private")) (_o$7566 #t)) (jolt-hash-map _o$7565 _o$7566)))) + (def-var-with-meta! "jolt.backend-scheme" "dl-munge" (letrec ((dl-munge (lambda (s) (let fnrec7599 ((s s)) (jolt-invoke (var-deref "clojure.string" "replace") (jolt-invoke (var-deref "clojure.string" "replace") (jolt-invoke (var-deref "clojure.string" "replace") s "$" "_D_") "#" "_H_") "'" "_Q_"))))) dl-munge) (let* ((_o$7600 (keyword #f "private")) (_o$7601 #t)) (jolt-hash-map _o$7600 _o$7601)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "dl-name" (letrec ((dl-name (lambda (ns nm) (let fnrec7567 ((ns ns) (nm nm)) (let* ((_a$7568 (var-deref "clojure.core" "str")) (_a$7569 "jv$") (_a$7570 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") ns)) (_a$7571 "$") (_a$7572 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") nm))) (jolt-invoke _a$7568 _a$7569 _a$7570 _a$7571 _a$7572)))))) dl-name) (let* ((_o$7573 (keyword #f "private")) (_o$7574 #t)) (jolt-hash-map _o$7573 _o$7574)))) + (def-var-with-meta! "jolt.backend-scheme" "dl-name" (letrec ((dl-name (lambda (ns nm) (let fnrec7602 ((ns ns) (nm nm)) (let* ((_a$7603 (var-deref "clojure.core" "str")) (_a$7604 "jv$") (_a$7605 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") ns)) (_a$7606 "$") (_a$7607 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") nm))) (jolt-invoke _a$7603 _a$7604 _a$7605 _a$7606 _a$7607)))))) dl-name) (let* ((_o$7608 (keyword #f "private")) (_o$7609 #t)) (jolt-hash-map _o$7608 _o$7609)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "dl-fqn" (letrec ((dl-fqn (lambda (ns nm) (let fnrec7575 ((ns ns) (nm nm)) (jolt-invoke (var-deref "clojure.core" "str") ns "/" nm))))) dl-fqn) (let* ((_o$7576 (keyword #f "private")) (_o$7577 #t)) (jolt-hash-map _o$7576 _o$7577)))) + (def-var-with-meta! "jolt.backend-scheme" "dl-fqn" (letrec ((dl-fqn (lambda (ns nm) (let fnrec7610 ((ns ns) (nm nm)) (jolt-invoke (var-deref "clojure.core" "str") ns "/" nm))))) dl-fqn) (let* ((_o$7611 (keyword #f "private")) (_o$7612 #t)) (jolt-hash-map _o$7611 _o$7612)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "direct-linkable?" (letrec ((direct-linkable? (lambda (ns nm) (let fnrec7578 ((ns ns) (nm nm)) (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link?")))) (if (jolt-truthy? and__25__auto) (let* ((_a$7579 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-defined"))) (_a$7580 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$7579 _a$7580)) and__25__auto)))))) direct-linkable?) (let* ((_o$7581 (keyword #f "private")) (_o$7582 #t)) (jolt-hash-map _o$7581 _o$7582)))) + (def-var-with-meta! "jolt.backend-scheme" "direct-linkable?" (letrec ((direct-linkable? (lambda (ns nm) (let fnrec7613 ((ns ns) (nm nm)) (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link?")))) (if (jolt-truthy? and__25__auto) (let* ((_a$7614 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-defined"))) (_a$7615 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$7614 _a$7615)) and__25__auto)))))) direct-linkable?) (let* ((_o$7616 (keyword #f "private")) (_o$7617 #t)) (jolt-hash-map _o$7616 _o$7617)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "direct-link-fn?" (letrec ((direct-link-fn? (lambda (ns nm) (let fnrec7583 ((ns ns) (nm nm)) (let* ((_a$7584 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-fns"))) (_a$7585 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$7584 _a$7585)))))) direct-link-fn?) (let* ((_o$7586 (keyword #f "private")) (_o$7587 #t)) (jolt-hash-map _o$7586 _o$7587)))) + (def-var-with-meta! "jolt.backend-scheme" "direct-link-fn?" (letrec ((direct-link-fn? (lambda (ns nm) (let fnrec7618 ((ns ns) (nm nm)) (let* ((_a$7619 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-fns"))) (_a$7620 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$7619 _a$7620)))))) direct-link-fn?) (let* ((_o$7621 (keyword #f "private")) (_o$7622 #t)) (jolt-hash-map _o$7621 _o$7622)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "*recur-target*" jolt-nil (let* ((_o$7588 (keyword #f "dynamic")) (_o$7589 #t)) (jolt-hash-map _o$7588 _o$7589)))) + (def-var-with-meta! "jolt.backend-scheme" "*recur-target*" jolt-nil (let* ((_o$7623 (keyword #f "dynamic")) (_o$7624 #t)) (jolt-hash-map _o$7623 _o$7624)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "*known-procs*" (jolt-hash-set) (let* ((_o$7590 (keyword #f "dynamic")) (_o$7591 #t)) (jolt-hash-map _o$7590 _o$7591)))) + (def-var-with-meta! "jolt.backend-scheme" "*known-procs*" (jolt-hash-set) (let* ((_o$7625 (keyword #f "dynamic")) (_o$7626 #t)) (jolt-hash-map _o$7625 _o$7626)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "gensym-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$7592 (keyword #f "private")) (_o$7593 #t)) (jolt-hash-map _o$7592 _o$7593)))) + (def-var-with-meta! "jolt.backend-scheme" "gensym-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$7627 (keyword #f "private")) (_o$7628 #t)) (jolt-hash-map _o$7627 _o$7628)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "fresh-label" (letrec ((fresh-label (lambda (prefix) (let fnrec7594 ((prefix prefix)) (jolt-invoke (var-deref "clojure.core" "str") prefix (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.backend-scheme" "gensym-counter") jolt-inc)))))) fresh-label) (let* ((_o$7595 (keyword #f "private")) (_o$7596 #t)) (jolt-hash-map _o$7595 _o$7596)))) + (def-var-with-meta! "jolt.backend-scheme" "fresh-label" (letrec ((fresh-label (lambda (prefix) (let fnrec7629 ((prefix prefix)) (jolt-invoke (var-deref "clojure.core" "str") prefix (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.backend-scheme" "gensym-counter") jolt-inc)))))) fresh-label) (let* ((_o$7630 (keyword #f "private")) (_o$7631 #t)) (jolt-hash-map _o$7630 _o$7631)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "devirt-cells" (jolt-invoke (var-deref "clojure.core" "atom") jolt-nil) (let* ((_o$7597 (keyword #f "private")) (_o$7598 #t)) (jolt-hash-map _o$7597 _o$7598)))) + (def-var-with-meta! "jolt.backend-scheme" "devirt-cells" (jolt-invoke (var-deref "clojure.core" "atom") jolt-nil) (let* ((_o$7632 (keyword #f "private")) (_o$7633 #t)) (jolt-hash-map _o$7632 _o$7633)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "scheme-reserved" (let* ((_o$7599 "if") (_o$7600 "begin") (_o$7601 "lambda") (_o$7602 "let") (_o$7603 "let*") (_o$7604 "letrec") (_o$7605 "letrec*") (_o$7606 "quote") (_o$7607 "quasiquote") (_o$7608 "unquote") (_o$7609 "set!") (_o$7610 "define") (_o$7611 "define-syntax") (_o$7612 "cond") (_o$7613 "case") (_o$7614 "when") (_o$7615 "unless") (_o$7616 "and") (_o$7617 "or") (_o$7618 "do") (_o$7619 "else") (_o$7620 "guard") (_o$7621 "parameterize") (_o$7622 "delay") (_o$7623 "values")) (jolt-hash-set _o$7599 _o$7600 _o$7601 _o$7602 _o$7603 _o$7604 _o$7605 _o$7606 _o$7607 _o$7608 _o$7609 _o$7610 _o$7611 _o$7612 _o$7613 _o$7614 _o$7615 _o$7616 _o$7617 _o$7618 _o$7619 _o$7620 _o$7621 _o$7622 _o$7623)) (let* ((_o$7624 (keyword #f "private")) (_o$7625 #t)) (jolt-hash-map _o$7624 _o$7625)))) + (def-var-with-meta! "jolt.backend-scheme" "scheme-reserved" (let* ((_o$7634 "if") (_o$7635 "begin") (_o$7636 "lambda") (_o$7637 "let") (_o$7638 "let*") (_o$7639 "letrec") (_o$7640 "letrec*") (_o$7641 "quote") (_o$7642 "quasiquote") (_o$7643 "unquote") (_o$7644 "set!") (_o$7645 "define") (_o$7646 "define-syntax") (_o$7647 "cond") (_o$7648 "case") (_o$7649 "when") (_o$7650 "unless") (_o$7651 "and") (_o$7652 "or") (_o$7653 "do") (_o$7654 "else") (_o$7655 "guard") (_o$7656 "parameterize") (_o$7657 "delay") (_o$7658 "values")) (jolt-hash-set _o$7634 _o$7635 _o$7636 _o$7637 _o$7638 _o$7639 _o$7640 _o$7641 _o$7642 _o$7643 _o$7644 _o$7645 _o$7646 _o$7647 _o$7648 _o$7649 _o$7650 _o$7651 _o$7652 _o$7653 _o$7654 _o$7655 _o$7656 _o$7657 _o$7658)) (let* ((_o$7659 (keyword #f "private")) (_o$7660 #t)) (jolt-hash-map _o$7659 _o$7660)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "bare-native-names" (jolt-invoke (var-deref "clojure.core" "set") (jolt-invoke (var-deref "clojure.core" "keep") (lambda (G__138) (let fnrec7626 ((G__138 G__138)) (let* ((G__139 G__138) (k (jolt-nth G__139 0 jolt-nil)) (v (jolt-nth G__139 1 jolt-nil))) (if (jolt= k v) k jolt-nil)))) (var-deref "jolt.backend-scheme" "native-ops"))) (let* ((_o$7627 (keyword #f "private")) (_o$7628 #t)) (jolt-hash-map _o$7627 _o$7628)))) + (def-var-with-meta! "jolt.backend-scheme" "bare-native-names" (jolt-invoke (var-deref "clojure.core" "set") (jolt-invoke (var-deref "clojure.core" "keep") (lambda (G__138) (let fnrec7661 ((G__138 G__138)) (let* ((G__139 G__138) (k (jolt-nth G__139 0 jolt-nil)) (v (jolt-nth G__139 1 jolt-nil))) (if (jolt= k v) k jolt-nil)))) (var-deref "jolt.backend-scheme" "native-ops"))) (let* ((_o$7662 (keyword #f "private")) (_o$7663 #t)) (jolt-hash-map _o$7662 _o$7663)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "munge-name" (letrec ((munge-name (lambda (s) (let fnrec7629 ((s s)) (let* ((s (jolt-invoke (var-deref "clojure.string" "replace") (jolt-invoke (var-deref "clojure.string" "replace") s "#" "_") "'" "_PRIME_"))) (if (let* ((or__26__auto (jolt-contains? (var-deref "jolt.backend-scheme" "scheme-reserved") s))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-contains? (var-deref "jolt.backend-scheme" "bare-native-names") s))) (jolt-invoke (var-deref "clojure.core" "str") "_" s) s)))))) munge-name) (let* ((_o$7630 (keyword #f "private")) (_o$7631 #t)) (jolt-hash-map _o$7630 _o$7631)))) + (def-var-with-meta! "jolt.backend-scheme" "munge-name" (letrec ((munge-name (lambda (s) (let fnrec7664 ((s s)) (let* ((s (jolt-invoke (var-deref "clojure.string" "replace") (jolt-invoke (var-deref "clojure.string" "replace") s "#" "_") "'" "_PRIME_"))) (if (let* ((or__26__auto (jolt-contains? (var-deref "jolt.backend-scheme" "scheme-reserved") s))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-contains? (var-deref "jolt.backend-scheme" "bare-native-names") s))) (jolt-invoke (var-deref "clojure.core" "str") "_" s) s)))))) munge-name) (let* ((_o$7665 (keyword #f "private")) (_o$7666 #t)) (jolt-hash-map _o$7665 _o$7666)))) (guard (e (#t #f)) (declare-var! "jolt.backend-scheme" "emit")) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "char-escape" (letrec ((char-escape (lambda (cp) (let fnrec7632 ((cp cp)) (if (jolt= cp 34) "\\\"" (if (jolt= cp 92) "\\\\" (if (jolt= cp 10) "\\n" (if (jolt= cp 9) "\\t" (if (jolt= cp 13) "\\r" (if (let* ((and__25__auto (>= cp 32))) (if (jolt-truthy? and__25__auto) (< cp 127) and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") (jolt-invoke (var-deref "clojure.core" "char") cp)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "str") "\\x" (jolt-invoke (var-deref "clojure.core" "format") "%x" cp) ";") jolt-nil))))))))))) char-escape) (let* ((_o$7633 (keyword #f "private")) (_o$7634 #t)) (jolt-hash-map _o$7633 _o$7634)))) + (def-var-with-meta! "jolt.backend-scheme" "char-escape" (letrec ((char-escape (lambda (cp) (let fnrec7667 ((cp cp)) (if (jolt= cp 34) "\\\"" (if (jolt= cp 92) "\\\\" (if (jolt= cp 10) "\\n" (if (jolt= cp 9) "\\t" (if (jolt= cp 13) "\\r" (if (let* ((and__25__auto (>= cp 32))) (if (jolt-truthy? and__25__auto) (< cp 127) and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") (jolt-invoke (var-deref "clojure.core" "char") cp)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "str") "\\x" (jolt-invoke (var-deref "clojure.core" "format") "%x" cp) ";") jolt-nil))))))))))) char-escape) (let* ((_o$7668 (keyword #f "private")) (_o$7669 #t)) (jolt-hash-map _o$7668 _o$7669)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "chez-str-lit" (letrec ((chez-str-lit (lambda (s) (let fnrec7635 ((s s)) (jolt-invoke (var-deref "clojure.core" "str") "\"" (jolt-apply (var-deref "clojure.core" "str") (jolt-map (lambda (c) (let fnrec7636 ((c c)) (jolt-invoke (var-deref "jolt.backend-scheme" "char-escape") (jolt-invoke (var-deref "clojure.core" "int") c)))) s)) "\""))))) chez-str-lit) (let* ((_o$7637 (keyword #f "private")) (_o$7638 #t)) (jolt-hash-map _o$7637 _o$7638)))) + (def-var-with-meta! "jolt.backend-scheme" "chez-str-lit" (letrec ((chez-str-lit (lambda (s) (let fnrec7670 ((s s)) (jolt-invoke (var-deref "clojure.core" "str") "\"" (jolt-apply (var-deref "clojure.core" "str") (jolt-map (lambda (c) (let fnrec7671 ((c c)) (jolt-invoke (var-deref "jolt.backend-scheme" "char-escape") (jolt-invoke (var-deref "clojure.core" "int") c)))) s)) "\""))))) chez-str-lit) (let* ((_o$7672 (keyword #f "private")) (_o$7673 #t)) (jolt-hash-map _o$7672 _o$7673)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-const" (letrec ((emit-const (lambda (v) (let fnrec7639 ((v v)) (if (jolt-nil? v) "jolt-nil" (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "boolean?") v)) (if (jolt-truthy? v) "#t" "#f") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") v)) (if (jolt= v +inf.0) "+inf.0" (if (jolt= v -inf.0) "-inf.0" (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "not=") v v)) "+nan.0" (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "float?") v)) (let* ((s (jolt-invoke (var-deref "clojure.core" "str") v))) (if (jolt-truthy? (let* ((or__26__auto (jolt-invoke (var-deref "clojure.string" "includes?") s "."))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-invoke (var-deref "clojure.string" "includes?") s "e")))) s (jolt-invoke (var-deref "clojure.core" "str") s ".0"))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "str") v) jolt-nil))))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") v)) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") v) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "keyword?") v)) (let* ((temp__16__auto (jolt-invoke (var-deref "clojure.core" "namespace") v))) (if (jolt-truthy? temp__16__auto) (let* ((kns temp__16__auto)) (let* ((_a$7640 (var-deref "clojure.core" "str")) (_a$7641 "(keyword ") (_a$7642 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") kns)) (_a$7643 " ") (_a$7644 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "clojure.core" "name") v))) (_a$7645 ")")) (jolt-invoke _a$7640 _a$7641 _a$7642 _a$7643 _a$7644 _a$7645))) (jolt-invoke (var-deref "clojure.core" "str") "(keyword #f " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "clojure.core" "name") v)) ")"))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-char?") v)) (jolt-invoke (var-deref "clojure.core" "str") "(integer->char " (jolt-invoke (var-deref "jolt.host" "form-char-code") v) ")") (if (jolt-truthy? (keyword #f "else")) (jolt-throw (let* ((_a$7646 (jolt-invoke (var-deref "clojure.core" "str") "emit-const: unsupported literal " (jolt-invoke (var-deref "clojure.core" "pr-str") v))) (_a$7647 (jolt-hash-map))) (jolt-ex-info _a$7646 _a$7647))) jolt-nil))))))))))) emit-const) (let* ((_o$7648 (keyword #f "private")) (_o$7649 #t)) (jolt-hash-map _o$7648 _o$7649)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-const" (letrec ((emit-const (lambda (v) (let fnrec7674 ((v v)) (if (jolt-nil? v) "jolt-nil" (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "boolean?") v)) (if (jolt-truthy? v) "#t" "#f") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") v)) (if (jolt= v +inf.0) "+inf.0" (if (jolt= v -inf.0) "-inf.0" (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "not=") v v)) "+nan.0" (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "float?") v)) (let* ((s (jolt-invoke (var-deref "clojure.core" "str") v))) (if (jolt-truthy? (let* ((or__26__auto (jolt-invoke (var-deref "clojure.string" "includes?") s "."))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-invoke (var-deref "clojure.string" "includes?") s "e")))) s (jolt-invoke (var-deref "clojure.core" "str") s ".0"))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "str") v) jolt-nil))))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") v)) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") v) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "keyword?") v)) (let* ((temp__16__auto (jolt-invoke (var-deref "clojure.core" "namespace") v))) (if (jolt-truthy? temp__16__auto) (let* ((kns temp__16__auto)) (let* ((_a$7675 (var-deref "clojure.core" "str")) (_a$7676 "(keyword ") (_a$7677 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") kns)) (_a$7678 " ") (_a$7679 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "clojure.core" "name") v))) (_a$7680 ")")) (jolt-invoke _a$7675 _a$7676 _a$7677 _a$7678 _a$7679 _a$7680))) (jolt-invoke (var-deref "clojure.core" "str") "(keyword #f " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "clojure.core" "name") v)) ")"))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-char?") v)) (jolt-invoke (var-deref "clojure.core" "str") "(integer->char " (jolt-invoke (var-deref "jolt.host" "form-char-code") v) ")") (if (jolt-truthy? (keyword #f "else")) (jolt-throw (let* ((_a$7681 (jolt-invoke (var-deref "clojure.core" "str") "emit-const: unsupported literal " (jolt-invoke (var-deref "clojure.core" "pr-str") v))) (_a$7682 (jolt-hash-map))) (jolt-ex-info _a$7681 _a$7682))) jolt-nil))))))))))) emit-const) (let* ((_o$7683 (keyword #f "private")) (_o$7684 #t)) (jolt-hash-map _o$7683 _o$7684)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-ordered" (letrec ((emit-ordered (lambda (ctor arg-strs) (let fnrec7650 ((ctor ctor) (arg-strs arg-strs)) (if (< (jolt-count arg-strs) 2) (jolt-invoke (var-deref "clojure.core" "str") "(" ctor (if (jolt-empty? arg-strs) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " arg-strs))) ")") (let* ((tmps (jolt-map (lambda (_) (let fnrec7651 ((_ _)) (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_o$"))) arg-strs)) (binds (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (t a) (let fnrec7652 ((t t) (a a)) (jolt-invoke (var-deref "clojure.core" "str") "(" t " " a ")"))) tmps arg-strs)))) (jolt-invoke (var-deref "clojure.core" "str") "(let* (" binds ") (" ctor " " (jolt-invoke (var-deref "clojure.string" "join") " " tmps) "))"))))))) emit-ordered) (let* ((_o$7653 (keyword #f "private")) (_o$7654 #t)) (jolt-hash-map _o$7653 _o$7654)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-ordered" (letrec ((emit-ordered (lambda (ctor arg-strs) (let fnrec7685 ((ctor ctor) (arg-strs arg-strs)) (if (< (jolt-count arg-strs) 2) (jolt-invoke (var-deref "clojure.core" "str") "(" ctor (if (jolt-empty? arg-strs) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " arg-strs))) ")") (let* ((tmps (jolt-map (lambda (_) (let fnrec7686 ((_ _)) (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_o$"))) arg-strs)) (binds (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (t a) (let fnrec7687 ((t t) (a a)) (jolt-invoke (var-deref "clojure.core" "str") "(" t " " a ")"))) tmps arg-strs)))) (jolt-invoke (var-deref "clojure.core" "str") "(let* (" binds ") (" ctor " " (jolt-invoke (var-deref "clojure.string" "join") " " tmps) "))"))))))) emit-ordered) (let* ((_o$7688 (keyword #f "private")) (_o$7689 #t)) (jolt-hash-map _o$7688 _o$7689)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "side-effect-free?" (letrec ((side-effect-free? (lambda (n) (let fnrec7655 ((n n)) (let* ((_a$7661 (let* ((_o$7656 (keyword #f "const")) (_o$7657 (keyword #f "local")) (_o$7658 (keyword #f "var")) (_o$7659 (keyword #f "the-var")) (_o$7660 (keyword #f "quote"))) (jolt-hash-set _o$7656 _o$7657 _o$7658 _o$7659 _o$7660))) (_a$7662 (jolt-get n (keyword #f "op")))) (jolt-contains? _a$7661 _a$7662)))))) side-effect-free?) (let* ((_o$7663 (keyword #f "private")) (_o$7664 #t)) (jolt-hash-map _o$7663 _o$7664)))) + (def-var-with-meta! "jolt.backend-scheme" "side-effect-free?" (letrec ((side-effect-free? (lambda (n) (let fnrec7690 ((n n)) (let* ((_a$7696 (let* ((_o$7691 (keyword #f "const")) (_o$7692 (keyword #f "local")) (_o$7693 (keyword #f "var")) (_o$7694 (keyword #f "the-var")) (_o$7695 (keyword #f "quote"))) (jolt-hash-set _o$7691 _o$7692 _o$7693 _o$7694 _o$7695))) (_a$7697 (jolt-get n (keyword #f "op")))) (jolt-contains? _a$7696 _a$7697)))))) side-effect-free?) (let* ((_o$7698 (keyword #f "private")) (_o$7699 #t)) (jolt-hash-map _o$7698 _o$7699)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "needs-order?" (letrec ((needs-order? (lambda (nodes) (let fnrec7665 ((nodes nodes)) (> (jolt-count (jolt-remove (var-deref "jolt.backend-scheme" "side-effect-free?") nodes)) 1))))) needs-order?) (let* ((_o$7666 (keyword #f "private")) (_o$7667 #t)) (jolt-hash-map _o$7666 _o$7667)))) + (def-var-with-meta! "jolt.backend-scheme" "needs-order?" (letrec ((needs-order? (lambda (nodes) (let fnrec7700 ((nodes nodes)) (> (jolt-count (jolt-remove (var-deref "jolt.backend-scheme" "side-effect-free?") nodes)) 1))))) needs-order?) (let* ((_o$7701 (keyword #f "private")) (_o$7702 #t)) (jolt-hash-map _o$7701 _o$7702)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "ordered-call" (letrec ((ordered-call (lambda (nodes strs build) (let fnrec7668 ((nodes nodes) (strs strs) (build build)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "needs-order?") nodes)) (let* ((tmps (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (_) (let fnrec7669 ((_ _)) (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_a$"))) strs)) (binds (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (t a) (let fnrec7670 ((t t) (a a)) (jolt-invoke (var-deref "clojure.core" "str") "(" t " " a ")"))) tmps strs)))) (jolt-invoke (var-deref "clojure.core" "str") "(let* (" binds ") " (jolt-invoke build tmps) ")")) (jolt-invoke build strs)))))) ordered-call) (let* ((_o$7671 (keyword #f "private")) (_o$7672 #t)) (jolt-hash-map _o$7671 _o$7672)))) + (def-var-with-meta! "jolt.backend-scheme" "ordered-call" (letrec ((ordered-call (lambda (nodes strs build) (let fnrec7703 ((nodes nodes) (strs strs) (build build)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "needs-order?") nodes)) (let* ((tmps (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (_) (let fnrec7704 ((_ _)) (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_a$"))) strs)) (binds (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (t a) (let fnrec7705 ((t t) (a a)) (jolt-invoke (var-deref "clojure.core" "str") "(" t " " a ")"))) tmps strs)))) (jolt-invoke (var-deref "clojure.core" "str") "(let* (" binds ") " (jolt-invoke build tmps) ")")) (jolt-invoke build strs)))))) ordered-call) (let* ((_o$7706 (keyword #f "private")) (_o$7707 #t)) (jolt-hash-map _o$7706 _o$7707)))) (guard (e (#t #f)) (declare-var! "jolt.backend-scheme" "emit-quoted")) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-quoted-map" (letrec ((emit-quoted-map (lambda (pairs) (let fnrec7673 ((pairs pairs)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-map " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-invoke (var-deref "clojure.core" "mapcat") (lambda (p) (let fnrec7674 ((p p)) (let* ((_o$7675 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 0))) (_o$7676 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 1)))) (jolt-vector _o$7675 _o$7676)))) pairs)) ")"))))) emit-quoted-map) (let* ((_o$7677 (keyword #f "private")) (_o$7678 #t)) (jolt-hash-map _o$7677 _o$7678)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-quoted-map" (letrec ((emit-quoted-map (lambda (pairs) (let fnrec7708 ((pairs pairs)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-map " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-invoke (var-deref "clojure.core" "mapcat") (lambda (p) (let fnrec7709 ((p p)) (let* ((_o$7710 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 0))) (_o$7711 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 1)))) (jolt-vector _o$7710 _o$7711)))) pairs)) ")"))))) emit-quoted-map) (let* ((_o$7712 (keyword #f "private")) (_o$7713 #t)) (jolt-hash-map _o$7712 _o$7713)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-quoted-map-value" (letrec ((emit-quoted-map-value (lambda (m) (let fnrec7679 ((m m)) (let* ((pairs (jolt-invoke (var-deref "clojure.core" "sort") (let* ((_a$7685 (lambda (k) (let fnrec7680 ((k k)) (let* ((_a$7681 (var-deref "clojure.core" "str")) (_a$7682 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") k)) (_a$7683 " ") (_a$7684 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get m k)))) (jolt-invoke _a$7681 _a$7682 _a$7683 _a$7684))))) (_a$7686 (jolt-keys m))) (jolt-map _a$7685 _a$7686))))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-map " (jolt-invoke (var-deref "clojure.string" "join") " " pairs) ")")))))) emit-quoted-map-value) (let* ((_o$7687 (keyword #f "private")) (_o$7688 #t)) (jolt-hash-map _o$7687 _o$7688)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-quoted-map-value" (letrec ((emit-quoted-map-value (lambda (m) (let fnrec7714 ((m m)) (let* ((pairs (jolt-invoke (var-deref "clojure.core" "sort") (let* ((_a$7720 (lambda (k) (let fnrec7715 ((k k)) (let* ((_a$7716 (var-deref "clojure.core" "str")) (_a$7717 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") k)) (_a$7718 " ") (_a$7719 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get m k)))) (jolt-invoke _a$7716 _a$7717 _a$7718 _a$7719))))) (_a$7721 (jolt-keys m))) (jolt-map _a$7720 _a$7721))))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-map " (jolt-invoke (var-deref "clojure.string" "join") " " pairs) ")")))))) emit-quoted-map-value) (let* ((_o$7722 (keyword #f "private")) (_o$7723 #t)) (jolt-hash-map _o$7722 _o$7723)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-quoted" (letrec ((emit-quoted (lambda (form) (let fnrec7689 ((form form)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-char?") form)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") form) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-literal?") form)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") form) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") form)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") form)) (sns (jolt-invoke (var-deref "jolt.host" "form-sym-ns") form)) (nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") form))) (if (jolt-truthy? (let* ((and__25__auto m)) (if (jolt-truthy? and__25__auto) (jolt-pos? (jolt-count m)) and__25__auto))) (let* ((_a$7690 (var-deref "clojure.core" "str")) (_a$7691 "(jolt-symbol/meta ") (_a$7692 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$7693 " ") (_a$7694 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7695 " ") (_a$7696 (emit-quoted m)) (_a$7697 ")")) (jolt-invoke _a$7690 _a$7691 _a$7692 _a$7693 _a$7694 _a$7695 _a$7696 _a$7697)) (let* ((_a$7698 (var-deref "clojure.core" "str")) (_a$7699 "(jolt-symbol ") (_a$7700 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$7701 " ") (_a$7702 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7703 ")")) (jolt-invoke _a$7698 _a$7699 _a$7700 _a$7701 _a$7702 _a$7703)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-set?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-set " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-invoke (var-deref "clojure.core" "sort") (jolt-map emit-quoted (jolt-invoke (var-deref "jolt.host" "form-set-items") form)))) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-list " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-quoted (jolt-invoke (var-deref "jolt.host" "form-elements") form))) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-vec?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-vector " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-quoted (jolt-invoke (var-deref "jolt.host" "form-vec-items") form))) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-map?") form)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted-map") (jolt-invoke (var-deref "jolt.host" "form-map-pairs") form)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-regex?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-regex " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "jolt.host" "form-regex-source") form)) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-inst?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-inst-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "jolt.host" "form-inst-source") form)) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-uuid?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-uuid-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "jolt.host" "form-uuid-source") form)) ")") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") form)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted-map-value") form) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-vector " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-quoted form)) ")") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "set?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-set " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-invoke (var-deref "clojure.core" "sort") (jolt-map emit-quoted form))) ")") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-list " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-quoted form)) ")") (if (jolt-truthy? (keyword #f "else")) (jolt-throw (let* ((_a$7704 (jolt-invoke (var-deref "clojure.core" "str") "emit-quoted: unsupported quoted form " (jolt-invoke (var-deref "clojure.core" "pr-str") form))) (_a$7705 (jolt-hash-map))) (jolt-ex-info _a$7704 _a$7705))) jolt-nil))))))))))))))))))) emit-quoted) (let* ((_o$7706 (keyword #f "private")) (_o$7707 #t)) (jolt-hash-map _o$7706 _o$7707)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-quoted" (letrec ((emit-quoted (lambda (form) (let fnrec7724 ((form form)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-char?") form)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") form) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-literal?") form)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") form) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") form)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") form)) (sns (jolt-invoke (var-deref "jolt.host" "form-sym-ns") form)) (nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") form))) (if (jolt-truthy? (let* ((and__25__auto m)) (if (jolt-truthy? and__25__auto) (jolt-pos? (jolt-count m)) and__25__auto))) (let* ((_a$7725 (var-deref "clojure.core" "str")) (_a$7726 "(jolt-symbol/meta ") (_a$7727 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$7728 " ") (_a$7729 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7730 " ") (_a$7731 (emit-quoted m)) (_a$7732 ")")) (jolt-invoke _a$7725 _a$7726 _a$7727 _a$7728 _a$7729 _a$7730 _a$7731 _a$7732)) (let* ((_a$7733 (var-deref "clojure.core" "str")) (_a$7734 "(jolt-symbol ") (_a$7735 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$7736 " ") (_a$7737 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7738 ")")) (jolt-invoke _a$7733 _a$7734 _a$7735 _a$7736 _a$7737 _a$7738)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-set?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-set " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-invoke (var-deref "clojure.core" "sort") (jolt-map emit-quoted (jolt-invoke (var-deref "jolt.host" "form-set-items") form)))) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-list " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-quoted (jolt-invoke (var-deref "jolt.host" "form-elements") form))) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-vec?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-vector " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-quoted (jolt-invoke (var-deref "jolt.host" "form-vec-items") form))) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-map?") form)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted-map") (jolt-invoke (var-deref "jolt.host" "form-map-pairs") form)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-regex?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-regex " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "jolt.host" "form-regex-source") form)) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-inst?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-inst-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "jolt.host" "form-inst-source") form)) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-uuid?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-uuid-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "jolt.host" "form-uuid-source") form)) ")") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") form)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted-map-value") form) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-vector " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-quoted form)) ")") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "set?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-set " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-invoke (var-deref "clojure.core" "sort") (jolt-map emit-quoted form))) ")") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-list " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-quoted form)) ")") (if (jolt-truthy? (keyword #f "else")) (jolt-throw (let* ((_a$7739 (jolt-invoke (var-deref "clojure.core" "str") "emit-quoted: unsupported quoted form " (jolt-invoke (var-deref "clojure.core" "pr-str") form))) (_a$7740 (jolt-hash-map))) (jolt-ex-info _a$7739 _a$7740))) jolt-nil))))))))))))))))))) emit-quoted) (let* ((_o$7741 (keyword #f "private")) (_o$7742 #t)) (jolt-hash-map _o$7741 _o$7742)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "jmeta-nonempty?" (letrec ((jmeta-nonempty? (lambda (m) (let fnrec7708 ((m m)) (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "map?") m))) (if (jolt-truthy? and__25__auto) (jolt-pos? (jolt-count m)) and__25__auto)))))) jmeta-nonempty?) (let* ((_o$7709 (keyword #f "private")) (_o$7710 #t)) (jolt-hash-map _o$7709 _o$7710)))) + (def-var-with-meta! "jolt.backend-scheme" "jmeta-nonempty?" (letrec ((jmeta-nonempty? (lambda (m) (let fnrec7743 ((m m)) (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "map?") m))) (if (jolt-truthy? and__25__auto) (jolt-pos? (jolt-count m)) and__25__auto)))))) jmeta-nonempty?) (let* ((_o$7744 (keyword #f "private")) (_o$7745 #t)) (jolt-hash-map _o$7744 _o$7745)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-def-meta" (letrec ((emit-def-meta (lambda (node) (let fnrec7711 ((node node)) (if (jolt-truthy? (jolt-get node (keyword #f "meta-expr"))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "meta-expr"))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get node (keyword #f "meta")))))))) emit-def-meta) (let* ((_o$7712 (keyword #f "private")) (_o$7713 #t)) (jolt-hash-map _o$7712 _o$7713)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-def-meta" (letrec ((emit-def-meta (lambda (node) (let fnrec7746 ((node node)) (if (jolt-truthy? (jolt-get node (keyword #f "meta-expr"))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "meta-expr"))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get node (keyword #f "meta")))))))) emit-def-meta) (let* ((_o$7747 (keyword #f "private")) (_o$7748 #t)) (jolt-hash-map _o$7747 _o$7748)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-binding" (letrec ((emit-binding (lambda (b) (let fnrec7714 ((b b)) (let* ((_a$7715 (var-deref "clojure.core" "str")) (_a$7716 "(") (_a$7717 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-nth b 0))) (_a$7718 " ") (_a$7719 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth b 1))) (_a$7720 ")")) (jolt-invoke _a$7715 _a$7716 _a$7717 _a$7718 _a$7719 _a$7720)))))) emit-binding) (let* ((_o$7721 (keyword #f "private")) (_o$7722 #t)) (jolt-hash-map _o$7721 _o$7722)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-binding" (letrec ((emit-binding (lambda (b) (let fnrec7749 ((b b)) (let* ((_a$7750 (var-deref "clojure.core" "str")) (_a$7751 "(") (_a$7752 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-nth b 0))) (_a$7753 " ") (_a$7754 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth b 1))) (_a$7755 ")")) (jolt-invoke _a$7750 _a$7751 _a$7752 _a$7753 _a$7754 _a$7755)))))) emit-binding) (let* ((_o$7756 (keyword #f "private")) (_o$7757 #t)) (jolt-hash-map _o$7756 _o$7757)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-let" (letrec ((emit-let (lambda (node) (let fnrec7723 ((node node)) (let* ((kw (if (jolt-truthy? (jolt-get node (keyword #f "letrec"))) "letrec*" "let*"))) (let* ((_a$7724 (var-deref "clojure.core" "str")) (_a$7725 "(") (_a$7726 kw) (_a$7727 " (") (_a$7728 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "emit-binding") (jolt-get node (keyword #f "bindings"))))) (_a$7729 ") ") (_a$7730 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$7731 ")")) (jolt-invoke _a$7724 _a$7725 _a$7726 _a$7727 _a$7728 _a$7729 _a$7730 _a$7731))))))) emit-let) (let* ((_o$7732 (keyword #f "private")) (_o$7733 #t)) (jolt-hash-map _o$7732 _o$7733)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-let" (letrec ((emit-let (lambda (node) (let fnrec7758 ((node node)) (let* ((kw (if (jolt-truthy? (jolt-get node (keyword #f "letrec"))) "letrec*" "let*"))) (let* ((_a$7759 (var-deref "clojure.core" "str")) (_a$7760 "(") (_a$7761 kw) (_a$7762 " (") (_a$7763 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "emit-binding") (jolt-get node (keyword #f "bindings"))))) (_a$7764 ") ") (_a$7765 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$7766 ")")) (jolt-invoke _a$7759 _a$7760 _a$7761 _a$7762 _a$7763 _a$7764 _a$7765 _a$7766))))))) emit-let) (let* ((_o$7767 (keyword #f "private")) (_o$7768 #t)) (jolt-hash-map _o$7767 _o$7768)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-loop" (letrec ((emit-loop (lambda (node) (let fnrec7734 ((node node)) (let* ((label (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "loop")) (pairs (jolt-get node (keyword #f "bindings"))) (names (jolt-map (lambda (p__88_) (let fnrec7735 ((p__88_ p__88_)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-nth p__88_ 0)))) pairs)) (inits (jolt-map (lambda (p__89_) (let fnrec7736 ((p__89_ p__89_)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth p__89_ 1)))) pairs)) (seq-bs (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (n i) (let fnrec7737 ((n n) (i i)) (jolt-invoke (var-deref "clojure.core" "str") "(" n " " i ")"))) names inits))) (rebinds (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (n) (let fnrec7738 ((n n)) (jolt-invoke (var-deref "clojure.core" "str") "(" n " " n ")"))) names))) (body (let* ((frame__20__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "jolt.backend-scheme" "*recur-target*") label))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__20__auto) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings")))))))) (jolt-invoke (var-deref "clojure.core" "str") "(let* (" seq-bs ") (let " label " (" rebinds ") " body "))")))))) emit-loop) (let* ((_o$7739 (keyword #f "private")) (_o$7740 #t)) (jolt-hash-map _o$7739 _o$7740)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-loop" (letrec ((emit-loop (lambda (node) (let fnrec7769 ((node node)) (let* ((label (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "loop")) (pairs (jolt-get node (keyword #f "bindings"))) (names (jolt-map (lambda (p__95_) (let fnrec7770 ((p__95_ p__95_)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-nth p__95_ 0)))) pairs)) (inits (jolt-map (lambda (p__96_) (let fnrec7771 ((p__96_ p__96_)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth p__96_ 1)))) pairs)) (seq-bs (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (n i) (let fnrec7772 ((n n) (i i)) (jolt-invoke (var-deref "clojure.core" "str") "(" n " " i ")"))) names inits))) (rebinds (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (n) (let fnrec7773 ((n n)) (jolt-invoke (var-deref "clojure.core" "str") "(" n " " n ")"))) names))) (body (let* ((frame__20__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "jolt.backend-scheme" "*recur-target*") label))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__20__auto) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings")))))))) (jolt-invoke (var-deref "clojure.core" "str") "(let* (" seq-bs ") (let " label " (" rebinds ") " body "))")))))) emit-loop) (let* ((_o$7774 (keyword #f "private")) (_o$7775 #t)) (jolt-hash-map _o$7774 _o$7775)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "ffi-types" (let* ((_o$7741 "int") (_o$7742 "int") (_o$7743 "uint") (_o$7744 "unsigned-int") (_o$7745 "long") (_o$7746 "long") (_o$7747 "ulong") (_o$7748 "unsigned-long") (_o$7749 "int64") (_o$7750 "integer-64") (_o$7751 "uint64") (_o$7752 "unsigned-64") (_o$7753 "size_t") (_o$7754 "size_t") (_o$7755 "ssize_t") (_o$7756 "ssize_t") (_o$7757 "iptr") (_o$7758 "iptr") (_o$7759 "uptr") (_o$7760 "uptr") (_o$7761 "double") (_o$7762 "double") (_o$7763 "float") (_o$7764 "float") (_o$7765 "pointer") (_o$7766 "void*") (_o$7767 "void*") (_o$7768 "void*") (_o$7769 "string") (_o$7770 "string") (_o$7771 "void") (_o$7772 "void") (_o$7773 "uint8") (_o$7774 "unsigned-8") (_o$7775 "u8") (_o$7776 "unsigned-8") (_o$7777 "byte") (_o$7778 "unsigned-8") (_o$7779 "char") (_o$7780 "char")) (jolt-hash-map _o$7741 _o$7742 _o$7743 _o$7744 _o$7745 _o$7746 _o$7747 _o$7748 _o$7749 _o$7750 _o$7751 _o$7752 _o$7753 _o$7754 _o$7755 _o$7756 _o$7757 _o$7758 _o$7759 _o$7760 _o$7761 _o$7762 _o$7763 _o$7764 _o$7765 _o$7766 _o$7767 _o$7768 _o$7769 _o$7770 _o$7771 _o$7772 _o$7773 _o$7774 _o$7775 _o$7776 _o$7777 _o$7778 _o$7779 _o$7780)) (let* ((_o$7781 (keyword #f "private")) (_o$7782 #t)) (jolt-hash-map _o$7781 _o$7782)))) + (def-var-with-meta! "jolt.backend-scheme" "ffi-types" (let* ((_o$7776 "int") (_o$7777 "int") (_o$7778 "uint") (_o$7779 "unsigned-int") (_o$7780 "long") (_o$7781 "long") (_o$7782 "ulong") (_o$7783 "unsigned-long") (_o$7784 "int64") (_o$7785 "integer-64") (_o$7786 "uint64") (_o$7787 "unsigned-64") (_o$7788 "size_t") (_o$7789 "size_t") (_o$7790 "ssize_t") (_o$7791 "ssize_t") (_o$7792 "iptr") (_o$7793 "iptr") (_o$7794 "uptr") (_o$7795 "uptr") (_o$7796 "double") (_o$7797 "double") (_o$7798 "float") (_o$7799 "float") (_o$7800 "pointer") (_o$7801 "void*") (_o$7802 "void*") (_o$7803 "void*") (_o$7804 "string") (_o$7805 "string") (_o$7806 "void") (_o$7807 "void") (_o$7808 "uint8") (_o$7809 "unsigned-8") (_o$7810 "u8") (_o$7811 "unsigned-8") (_o$7812 "byte") (_o$7813 "unsigned-8") (_o$7814 "char") (_o$7815 "char")) (jolt-hash-map _o$7776 _o$7777 _o$7778 _o$7779 _o$7780 _o$7781 _o$7782 _o$7783 _o$7784 _o$7785 _o$7786 _o$7787 _o$7788 _o$7789 _o$7790 _o$7791 _o$7792 _o$7793 _o$7794 _o$7795 _o$7796 _o$7797 _o$7798 _o$7799 _o$7800 _o$7801 _o$7802 _o$7803 _o$7804 _o$7805 _o$7806 _o$7807 _o$7808 _o$7809 _o$7810 _o$7811 _o$7812 _o$7813 _o$7814 _o$7815)) (let* ((_o$7816 (keyword #f "private")) (_o$7817 #t)) (jolt-hash-map _o$7816 _o$7817)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "ffi-type->chez" (letrec ((ffi-type->chez (lambda (t) (let fnrec7783 ((t t)) (let* ((or__26__auto (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-types") t))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-throw (let* ((_a$7784 (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi: unknown foreign type :" t)) (_a$7785 (jolt-hash-map))) (jolt-ex-info _a$7784 _a$7785))))))))) ffi-type->chez) (let* ((_o$7786 (keyword #f "private")) (_o$7787 #t)) (jolt-hash-map _o$7786 _o$7787)))) + (def-var-with-meta! "jolt.backend-scheme" "ffi-type->chez" (letrec ((ffi-type->chez (lambda (t) (let fnrec7818 ((t t)) (let* ((or__26__auto (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-types") t))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-throw (let* ((_a$7819 (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi: unknown foreign type :" t)) (_a$7820 (jolt-hash-map))) (jolt-ex-info _a$7819 _a$7820))))))))) ffi-type->chez) (let* ((_o$7821 (keyword #f "private")) (_o$7822 #t)) (jolt-hash-map _o$7821 _o$7822)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-ffi-fn" (letrec ((emit-ffi-fn (lambda (node) (let fnrec7788 ((node node)) (let* ((_a$7789 (var-deref "clojure.core" "str")) (_a$7790 "(foreign-procedure ") (_a$7791 (if (jolt-truthy? (jolt-get node (keyword #f "blocking"))) "__collect_safe " jolt-nil)) (_a$7792 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "csym")))) (_a$7793 " (") (_a$7794 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$7795 ") ") (_a$7796 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$7797 ")")) (jolt-invoke _a$7789 _a$7790 _a$7791 _a$7792 _a$7793 _a$7794 _a$7795 _a$7796 _a$7797)))))) emit-ffi-fn) (let* ((_o$7798 (keyword #f "private")) (_o$7799 #t)) (jolt-hash-map _o$7798 _o$7799)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-ffi-fn" (letrec ((emit-ffi-fn (lambda (node) (let fnrec7823 ((node node)) (let* ((_a$7824 (var-deref "clojure.core" "str")) (_a$7825 "(foreign-procedure ") (_a$7826 (if (jolt-truthy? (jolt-get node (keyword #f "blocking"))) "__collect_safe " jolt-nil)) (_a$7827 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "csym")))) (_a$7828 " (") (_a$7829 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$7830 ") ") (_a$7831 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$7832 ")")) (jolt-invoke _a$7824 _a$7825 _a$7826 _a$7827 _a$7828 _a$7829 _a$7830 _a$7831 _a$7832)))))) emit-ffi-fn) (let* ((_o$7833 (keyword #f "private")) (_o$7834 #t)) (jolt-hash-map _o$7833 _o$7834)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-ffi-callable" (letrec ((emit-ffi-callable (lambda (node) (let fnrec7800 ((node node)) (let* ((_a$7801 (var-deref "clojure.core" "str")) (_a$7802 "(jolt-ffi-register-callable! (foreign-callable ") (_a$7803 (if (jolt-truthy? (jolt-get node (keyword #f "collect-safe"))) "__collect_safe " jolt-nil)) (_a$7804 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "fn")))) (_a$7805 " (") (_a$7806 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$7807 ") ") (_a$7808 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$7809 "))")) (jolt-invoke _a$7801 _a$7802 _a$7803 _a$7804 _a$7805 _a$7806 _a$7807 _a$7808 _a$7809)))))) emit-ffi-callable) (let* ((_o$7810 (keyword #f "private")) (_o$7811 #t)) (jolt-hash-map _o$7810 _o$7811)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-ffi-callable" (letrec ((emit-ffi-callable (lambda (node) (let fnrec7835 ((node node)) (let* ((_a$7836 (var-deref "clojure.core" "str")) (_a$7837 "(jolt-ffi-register-callable! (foreign-callable ") (_a$7838 (if (jolt-truthy? (jolt-get node (keyword #f "collect-safe"))) "__collect_safe " jolt-nil)) (_a$7839 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "fn")))) (_a$7840 " (") (_a$7841 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$7842 ") ") (_a$7843 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$7844 "))")) (jolt-invoke _a$7836 _a$7837 _a$7838 _a$7839 _a$7840 _a$7841 _a$7842 _a$7843 _a$7844)))))) emit-ffi-callable) (let* ((_o$7845 (keyword #f "private")) (_o$7846 #t)) (jolt-hash-map _o$7845 _o$7846)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-recur" (letrec ((emit-recur (lambda (node) (let fnrec7812 ((node node)) (begin (if (jolt-not (var-deref "jolt.backend-scheme" "*recur-target*")) (jolt-throw (jolt-ex-info "emit: recur outside a loop/fn target" (jolt-hash-map))) jolt-nil) (let* ((arg-nodes (jolt-get node (keyword #f "args")))) (let* ((_a$7814 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7815 arg-nodes) (_a$7816 (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit") arg-nodes)) (_a$7817 (lambda (as) (let fnrec7813 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" (var-deref "jolt.backend-scheme" "*recur-target*") " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")"))))) (jolt-invoke _a$7814 _a$7815 _a$7816 _a$7817)))))))) emit-recur) (let* ((_o$7818 (keyword #f "private")) (_o$7819 #t)) (jolt-hash-map _o$7818 _o$7819)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-recur" (letrec ((emit-recur (lambda (node) (let fnrec7847 ((node node)) (begin (if (jolt-not (var-deref "jolt.backend-scheme" "*recur-target*")) (jolt-throw (jolt-ex-info "emit: recur outside a loop/fn target" (jolt-hash-map))) jolt-nil) (let* ((arg-nodes (jolt-get node (keyword #f "args")))) (let* ((_a$7849 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7850 arg-nodes) (_a$7851 (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit") arg-nodes)) (_a$7852 (lambda (as) (let fnrec7848 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" (var-deref "jolt.backend-scheme" "*recur-target*") " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")"))))) (jolt-invoke _a$7849 _a$7850 _a$7851 _a$7852)))))))) emit-recur) (let* ((_o$7853 (keyword #f "private")) (_o$7854 #t)) (jolt-hash-map _o$7853 _o$7854)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "nhint-init" (letrec ((nhint-init (lambda (nh orig munged) (let fnrec7820 ((nh nh) (orig orig) (munged munged)) (let* ((k (jolt-get nh orig))) (if (jolt= k (keyword #f "double")) (jolt-invoke (var-deref "clojure.core" "str") "(exact->inexact " munged ")") (if (jolt= k (keyword #f "long")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt->fx " munged ")") (if (jolt-truthy? (keyword #f "else")) munged jolt-nil)))))))) nhint-init) (let* ((_o$7821 (keyword #f "private")) (_o$7822 #t)) (jolt-hash-map _o$7821 _o$7822)))) + (def-var-with-meta! "jolt.backend-scheme" "nhint-init" (letrec ((nhint-init (lambda (nh orig munged) (let fnrec7855 ((nh nh) (orig orig) (munged munged)) (let* ((k (jolt-get nh orig))) (if (jolt= k (keyword #f "double")) (jolt-invoke (var-deref "clojure.core" "str") "(exact->inexact " munged ")") (if (jolt= k (keyword #f "long")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt->fx " munged ")") (if (jolt-truthy? (keyword #f "else")) munged jolt-nil)))))))) nhint-init) (let* ((_o$7856 (keyword #f "private")) (_o$7857 #t)) (jolt-hash-map _o$7856 _o$7857)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-arity-clause" (letrec ((emit-arity-clause (lambda (a) (let fnrec7823 ((a a)) (let* ((orig (jolt-get a (keyword #f "params"))) (nh (let* ((_a$7824 (jolt-hash-map)) (_a$7825 (jolt-get a (keyword #f "nhints")))) (jolt-into _a$7824 _a$7825))) (params (jolt-map (var-deref "jolt.backend-scheme" "munge-name") orig)) (restp (let* ((temp__27__auto (jolt-get a (keyword #f "rest")))) (if (jolt-truthy? temp__27__auto) (let* ((r temp__27__auto)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") r)) jolt-nil))) (label (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "fnrec")) (body (let* ((frame__20__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "jolt.backend-scheme" "*recur-target*") label))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__20__auto) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get a (keyword #f "body")))) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings"))))))) (paramlist (if (jolt-truthy? (let* ((and__25__auto restp)) (if (jolt-truthy? and__25__auto) (jolt-empty? params) and__25__auto))) restp (if (jolt-truthy? restp) (jolt-invoke (var-deref "clojure.core" "str") "(" (jolt-invoke (var-deref "clojure.string" "join") " " params) " . " restp ")") (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "str") "(" (jolt-invoke (var-deref "clojure.string" "join") " " params) ")") jolt-nil)))) (pbind (jolt-map (lambda (o p) (let fnrec7826 ((o o) (p p)) (jolt-invoke (var-deref "clojure.core" "str") "(" p " " (jolt-invoke (var-deref "jolt.backend-scheme" "nhint-init") nh o p) ")"))) orig params)) (binds (if (jolt-truthy? restp) (jolt-concat pbind (jolt-vector (jolt-invoke (var-deref "clojure.core" "str") "(" restp " (list->cseq " restp "))"))) pbind)) (lett (jolt-invoke (var-deref "clojure.core" "str") "(let " label " (" (jolt-invoke (var-deref "clojure.string" "join") " " binds) ") " body ")")) (ret (jolt-get a (keyword #f "ret-nhint")))) (let* ((_o$7827 paramlist) (_o$7828 (if (jolt= ret (keyword #f "double")) (jolt-invoke (var-deref "clojure.core" "str") "(exact->inexact " lett ")") (if (jolt= ret (keyword #f "long")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt->fx " lett ")") (if (jolt-truthy? (keyword #f "else")) lett jolt-nil))))) (jolt-vector _o$7827 _o$7828))))))) emit-arity-clause) (let* ((_o$7829 (keyword #f "private")) (_o$7830 #t)) (jolt-hash-map _o$7829 _o$7830)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-arity-clause" (letrec ((emit-arity-clause (lambda (a) (let fnrec7858 ((a a)) (let* ((orig (jolt-get a (keyword #f "params"))) (nh (let* ((_a$7859 (jolt-hash-map)) (_a$7860 (jolt-get a (keyword #f "nhints")))) (jolt-into _a$7859 _a$7860))) (params (jolt-map (var-deref "jolt.backend-scheme" "munge-name") orig)) (restp (let* ((temp__27__auto (jolt-get a (keyword #f "rest")))) (if (jolt-truthy? temp__27__auto) (let* ((r temp__27__auto)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") r)) jolt-nil))) (label (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "fnrec")) (body (let* ((frame__20__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "jolt.backend-scheme" "*recur-target*") label))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__20__auto) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get a (keyword #f "body")))) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings"))))))) (paramlist (if (jolt-truthy? (let* ((and__25__auto restp)) (if (jolt-truthy? and__25__auto) (jolt-empty? params) and__25__auto))) restp (if (jolt-truthy? restp) (jolt-invoke (var-deref "clojure.core" "str") "(" (jolt-invoke (var-deref "clojure.string" "join") " " params) " . " restp ")") (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "str") "(" (jolt-invoke (var-deref "clojure.string" "join") " " params) ")") jolt-nil)))) (pbind (jolt-map (lambda (o p) (let fnrec7861 ((o o) (p p)) (jolt-invoke (var-deref "clojure.core" "str") "(" p " " (jolt-invoke (var-deref "jolt.backend-scheme" "nhint-init") nh o p) ")"))) orig params)) (binds (if (jolt-truthy? restp) (jolt-concat pbind (jolt-vector (jolt-invoke (var-deref "clojure.core" "str") "(" restp " (list->cseq " restp "))"))) pbind)) (lett (jolt-invoke (var-deref "clojure.core" "str") "(let " label " (" (jolt-invoke (var-deref "clojure.string" "join") " " binds) ") " body ")")) (ret (jolt-get a (keyword #f "ret-nhint")))) (let* ((_o$7862 paramlist) (_o$7863 (if (jolt= ret (keyword #f "double")) (jolt-invoke (var-deref "clojure.core" "str") "(exact->inexact " lett ")") (if (jolt= ret (keyword #f "long")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt->fx " lett ")") (if (jolt-truthy? (keyword #f "else")) lett jolt-nil))))) (jolt-vector _o$7862 _o$7863))))))) emit-arity-clause) (let* ((_o$7864 (keyword #f "private")) (_o$7865 #t)) (jolt-hash-map _o$7864 _o$7865)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-fn" (letrec ((emit-fn (lambda (node) (let fnrec7831 ((node node)) (let* ((arities (jolt-get node (keyword #f "arities"))) (self (let* ((temp__27__auto (jolt-get node (keyword #f "name")))) (if (jolt-truthy? temp__27__auto) (let* ((nm temp__27__auto)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") nm)) jolt-nil))) (clauses (let* ((frame__20__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "jolt.backend-scheme" "*known-procs*") (if (jolt-truthy? self) (jolt-conj (var-deref "jolt.backend-scheme" "*known-procs*") self) (var-deref "jolt.backend-scheme" "*known-procs*"))))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__20__auto) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit-arity-clause") arities)) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings"))))))) (_lambda (if (jolt= 1 (jolt-count clauses)) (let* ((c (jolt-first clauses))) (let* ((_a$7832 (var-deref "clojure.core" "str")) (_a$7833 "(lambda ") (_a$7834 (jolt-nth c 0)) (_a$7835 " ") (_a$7836 (jolt-nth c 1)) (_a$7837 ")")) (jolt-invoke _a$7832 _a$7833 _a$7834 _a$7835 _a$7836 _a$7837))) (jolt-invoke (var-deref "clojure.core" "str") "(case-lambda " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (c) (let fnrec7838 ((c c)) (let* ((_a$7839 (var-deref "clojure.core" "str")) (_a$7840 "(") (_a$7841 (jolt-nth c 0)) (_a$7842 " ") (_a$7843 (jolt-nth c 1)) (_a$7844 ")")) (jolt-invoke _a$7839 _a$7840 _a$7841 _a$7842 _a$7843 _a$7844)))) clauses)) ")")))) (let* ((temp__16__auto (jolt-get node (keyword #f "name")))) (if (jolt-truthy? temp__16__auto) (let* ((nm temp__16__auto)) (let* ((m (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") nm))) (jolt-invoke (var-deref "clojure.core" "str") "(letrec ((" m " " _lambda ")) " m ")"))) _lambda))))))) emit-fn) (let* ((_o$7845 (keyword #f "private")) (_o$7846 #t)) (jolt-hash-map _o$7845 _o$7846)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-fn" (letrec ((emit-fn (lambda (node) (let fnrec7866 ((node node)) (let* ((arities (jolt-get node (keyword #f "arities"))) (self (let* ((temp__27__auto (jolt-get node (keyword #f "name")))) (if (jolt-truthy? temp__27__auto) (let* ((nm temp__27__auto)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") nm)) jolt-nil))) (clauses (let* ((frame__20__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "jolt.backend-scheme" "*known-procs*") (if (jolt-truthy? self) (jolt-conj (var-deref "jolt.backend-scheme" "*known-procs*") self) (var-deref "jolt.backend-scheme" "*known-procs*"))))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__20__auto) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit-arity-clause") arities)) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings"))))))) (_lambda (if (jolt= 1 (jolt-count clauses)) (let* ((c (jolt-first clauses))) (let* ((_a$7867 (var-deref "clojure.core" "str")) (_a$7868 "(lambda ") (_a$7869 (jolt-nth c 0)) (_a$7870 " ") (_a$7871 (jolt-nth c 1)) (_a$7872 ")")) (jolt-invoke _a$7867 _a$7868 _a$7869 _a$7870 _a$7871 _a$7872))) (jolt-invoke (var-deref "clojure.core" "str") "(case-lambda " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (c) (let fnrec7873 ((c c)) (let* ((_a$7874 (var-deref "clojure.core" "str")) (_a$7875 "(") (_a$7876 (jolt-nth c 0)) (_a$7877 " ") (_a$7878 (jolt-nth c 1)) (_a$7879 ")")) (jolt-invoke _a$7874 _a$7875 _a$7876 _a$7877 _a$7878 _a$7879)))) clauses)) ")")))) (let* ((temp__16__auto (jolt-get node (keyword #f "name")))) (if (jolt-truthy? temp__16__auto) (let* ((nm temp__16__auto)) (let* ((m (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") nm))) (jolt-invoke (var-deref "clojure.core" "str") "(letrec ((" m " " _lambda ")) " m ")"))) _lambda))))))) emit-fn) (let* ((_o$7880 (keyword #f "private")) (_o$7881 #t)) (jolt-hash-map _o$7880 _o$7881)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "native-op" (letrec ((native-op (lambda (fnode nargs) (let fnrec7847 ((fnode fnode) (nargs nargs)) (let* ((nm (let* ((G__140 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__140 (keyword #f "var")) (if (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) (jolt-get fnode (keyword #f "name")) jolt-nil) (if (jolt= G__140 (keyword #f "host")) (jolt-get fnode (keyword #f "name")) jolt-nil)))) (op (if (jolt-truthy? nm) (jolt-invoke (var-deref "jolt.backend-scheme" "native-ops") nm) jolt-nil)) (arity-ok (if (jolt-truthy? nm) (jolt-invoke (var-deref "jolt.backend-scheme" "op-arity") nm) jolt-nil))) (if (jolt-nil? op) jolt-nil (if (jolt-truthy? (let* ((and__25__auto arity-ok)) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke arity-ok nargs)) and__25__auto))) jolt-nil (if (jolt-truthy? (keyword #f "else")) op jolt-nil)))))))) native-op) (let* ((_o$7848 (keyword #f "private")) (_o$7849 #t)) (jolt-hash-map _o$7848 _o$7849)))) + (def-var-with-meta! "jolt.backend-scheme" "native-op" (letrec ((native-op (lambda (fnode nargs) (let fnrec7882 ((fnode fnode) (nargs nargs)) (let* ((nm (let* ((G__140 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__140 (keyword #f "var")) (if (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) (jolt-get fnode (keyword #f "name")) jolt-nil) (if (jolt= G__140 (keyword #f "host")) (jolt-get fnode (keyword #f "name")) jolt-nil)))) (op (if (jolt-truthy? nm) (jolt-invoke (var-deref "jolt.backend-scheme" "native-ops") nm) jolt-nil)) (arity-ok (if (jolt-truthy? nm) (jolt-invoke (var-deref "jolt.backend-scheme" "op-arity") nm) jolt-nil))) (if (jolt-nil? op) jolt-nil (if (jolt-truthy? (let* ((and__25__auto arity-ok)) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke arity-ok nargs)) and__25__auto))) jolt-nil (if (jolt-truthy? (keyword #f "else")) op jolt-nil)))))))) native-op) (let* ((_o$7883 (keyword #f "private")) (_o$7884 #t)) (jolt-hash-map _o$7883 _o$7884)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "ifn-kind" (letrec ((ifn-kind (lambda (fnode) (let fnrec7850 ((fnode fnode)) (let* ((G__141 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__141 (keyword #f "const")) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "keyword?") (jolt-get fnode (keyword #f "val")))) (keyword #f "keyword") jolt-nil) (if (let* ((or__26__auto (jolt= G__141 (keyword #f "map")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= G__141 (keyword #f "set")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= G__141 (keyword #f "vector")))))) (keyword #f "coll") jolt-nil))))))) ifn-kind) (let* ((_o$7851 (keyword #f "private")) (_o$7852 #t)) (jolt-hash-map _o$7851 _o$7852)))) + (def-var-with-meta! "jolt.backend-scheme" "ifn-kind" (letrec ((ifn-kind (lambda (fnode) (let fnrec7885 ((fnode fnode)) (let* ((G__141 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__141 (keyword #f "const")) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "keyword?") (jolt-get fnode (keyword #f "val")))) (keyword #f "keyword") jolt-nil) (if (let* ((or__26__auto (jolt= G__141 (keyword #f "map")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= G__141 (keyword #f "set")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= G__141 (keyword #f "vector")))))) (keyword #f "coll") jolt-nil))))))) ifn-kind) (let* ((_o$7886 (keyword #f "private")) (_o$7887 #t)) (jolt-hash-map _o$7886 _o$7887)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "stdlib-var?" (letrec ((stdlib-var? (lambda (n) (let fnrec7853 ((n n)) (let* ((and__25__auto (jolt= (keyword #f "var") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.string" "starts-with?") (let* ((or__26__auto (jolt-get n (keyword #f "ns")))) (if (jolt-truthy? or__26__auto) or__26__auto "")) "clojure.") and__25__auto)))))) stdlib-var?) (let* ((_o$7854 (keyword #f "private")) (_o$7855 #t)) (jolt-hash-map _o$7854 _o$7855)))) + (def-var-with-meta! "jolt.backend-scheme" "stdlib-var?" (letrec ((stdlib-var? (lambda (n) (let fnrec7888 ((n n)) (let* ((and__25__auto (jolt= (keyword #f "var") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.string" "starts-with?") (let* ((or__26__auto (jolt-get n (keyword #f "ns")))) (if (jolt-truthy? or__26__auto) or__26__auto "")) "clojure.") and__25__auto)))))) stdlib-var?) (let* ((_o$7889 (keyword #f "private")) (_o$7890 #t)) (jolt-hash-map _o$7889 _o$7890)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-numeric" (letrec ((emit-numeric (lambda (kind nm args order-args) (let fnrec7856 ((kind kind) (nm nm) (args args) (order-args order-args)) (if (let* ((and__25__auto (jolt= kind (keyword #f "double")))) (if (jolt-truthy? and__25__auto) (jolt= nm "inc") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(fl+ " (jolt-first args) " 1.0)") (if (let* ((and__25__auto (jolt= kind (keyword #f "double")))) (if (jolt-truthy? and__25__auto) (jolt= nm "dec") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(fl- " (jolt-first args) " 1.0)") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (jolt= nm "inc") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-l-inc " (jolt-first args) ")") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (jolt= nm "dec") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-l-dec " (jolt-first args) ")") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (jolt= nm "unchecked-inc") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-uncinc " (jolt-first args) ")") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (jolt= nm "unchecked-dec") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-uncdec " (jolt-first args) ")") (if (jolt-truthy? (keyword #f "else")) (let* ((op (let* ((G__142 kind)) (if (jolt= G__142 (keyword #f "double")) (jolt-invoke (var-deref "jolt.backend-scheme" "dbl-ops") nm) (if (jolt= G__142 (keyword #f "long")) (jolt-invoke (var-deref "jolt.backend-scheme" "lng-ops") nm) (if (jolt= G__142 (keyword #f "bigdec")) (jolt-invoke (var-deref "jolt.backend-scheme" "bd-ops") nm) (jolt-throw (let* ((_a$7857 (jolt-invoke (var-deref "clojure.core" "str") "No matching clause: " G__142)) (_a$7858 (jolt-hash-map))) (jolt-ex-info _a$7857 _a$7858))))))))) (jolt-invoke order-args (lambda (as) (let fnrec7859 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" op " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")"))))) jolt-nil))))))))))) emit-numeric) (let* ((_o$7860 (keyword #f "private")) (_o$7861 #t)) (jolt-hash-map _o$7860 _o$7861)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-numeric" (letrec ((emit-numeric (lambda (kind nm args order-args) (let fnrec7891 ((kind kind) (nm nm) (args args) (order-args order-args)) (if (let* ((and__25__auto (jolt= kind (keyword #f "double")))) (if (jolt-truthy? and__25__auto) (jolt= nm "inc") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(fl+ " (jolt-first args) " 1.0)") (if (let* ((and__25__auto (jolt= kind (keyword #f "double")))) (if (jolt-truthy? and__25__auto) (jolt= nm "dec") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(fl- " (jolt-first args) " 1.0)") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (jolt= nm "inc") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-l-inc " (jolt-first args) ")") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (jolt= nm "dec") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-l-dec " (jolt-first args) ")") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (jolt= nm "unchecked-inc") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-uncinc " (jolt-first args) ")") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (jolt= nm "unchecked-dec") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-uncdec " (jolt-first args) ")") (if (jolt-truthy? (keyword #f "else")) (let* ((op (let* ((G__142 kind)) (if (jolt= G__142 (keyword #f "double")) (jolt-invoke (var-deref "jolt.backend-scheme" "dbl-ops") nm) (if (jolt= G__142 (keyword #f "long")) (jolt-invoke (var-deref "jolt.backend-scheme" "lng-ops") nm) (if (jolt= G__142 (keyword #f "bigdec")) (jolt-invoke (var-deref "jolt.backend-scheme" "bd-ops") nm) (jolt-throw (let* ((_a$7892 (jolt-invoke (var-deref "clojure.core" "str") "No matching clause: " G__142)) (_a$7893 (jolt-hash-map))) (jolt-ex-info _a$7892 _a$7893))))))))) (jolt-invoke order-args (lambda (as) (let fnrec7894 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" op " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")"))))) jolt-nil))))))))))) emit-numeric) (let* ((_o$7895 (keyword #f "private")) (_o$7896 #t)) (jolt-hash-map _o$7895 _o$7896)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "struct-field-index" (letrec ((struct-field-index (lambda (shape kw) (let fnrec7862 ((shape shape) (kw kw)) (if (jolt-truthy? shape) (let* ((i 0)) (let loop7863 ((i i)) (if (>= i (jolt-count shape)) jolt-nil (if (jolt= (jolt-nth shape i) kw) i (if (jolt-truthy? (keyword #f "else")) (loop7863 (jolt-inc i)) jolt-nil))))) jolt-nil))))) struct-field-index) (let* ((_o$7864 (keyword #f "private")) (_o$7865 #t)) (jolt-hash-map _o$7864 _o$7865)))) + (def-var-with-meta! "jolt.backend-scheme" "struct-field-index" (letrec ((struct-field-index (lambda (shape kw) (let fnrec7897 ((shape shape) (kw kw)) (if (jolt-truthy? shape) (let* ((i 0)) (let loop7898 ((i i)) (if (>= i (jolt-count shape)) jolt-nil (if (jolt= (jolt-nth shape i) kw) i (if (jolt-truthy? (keyword #f "else")) (loop7898 (jolt-inc i)) jolt-nil))))) jolt-nil))))) struct-field-index) (let* ((_o$7899 (keyword #f "private")) (_o$7900 #t)) (jolt-hash-map _o$7899 _o$7900)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-invoke" (letrec ((emit-invoke (lambda (node) (let fnrec7866 ((node node)) (let* ((fnode (jolt-get node (keyword #f "fn"))) (arg-nodes (jolt-get node (keyword #f "args"))) (args (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit") arg-nodes)) (nop (jolt-invoke (var-deref "jolt.backend-scheme" "native-op") fnode (jolt-count args))) (kind (jolt-invoke (var-deref "jolt.backend-scheme" "ifn-kind") fnode)) (order-args (lambda (build) (let fnrec7867 ((build build)) (jolt-invoke (var-deref "jolt.backend-scheme" "ordered-call") arg-nodes args build)))) (defstr (lambda (as) (let fnrec7868 ((as as)) (if (> (jolt-count as) 1) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-nth as 1)) "")))) (invoke (lambda () (let fnrec7869 () (let* ((_a$7871 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7872 (jolt-cons fnode arg-nodes)) (_a$7873 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$7874 (lambda (G__143) (let fnrec7870 ((G__143 G__143)) (let* ((G__144 G__143) (f (jolt-nth G__144 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__144 1))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-invoke " f (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "") ")")))))) (jolt-invoke _a$7871 _a$7872 _a$7873 _a$7874)))))) (if (jolt-truthy? (jolt-get node (keyword #f "devirt-type"))) (jolt-invoke order-args (lambda (as) (let fnrec7875 ((as as)) (let* ((r (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_r$")) (dv (let* ((_a$7876 (var-deref "clojure.core" "str")) (_a$7877 "(devirt-resolve ") (_a$7878 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-type")))) (_a$7879 " ") (_a$7880 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-proto")))) (_a$7881 " ") (_a$7882 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-method")))) (_a$7883 " ") (_a$7884 r) (_a$7885 ")")) (jolt-invoke _a$7876 _a$7877 _a$7878 _a$7879 _a$7880 _a$7881 _a$7882 _a$7883 _a$7884 _a$7885))) (cells (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "devirt-cells"))) (resolver (if (jolt-truthy? cells) (let* ((c (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_dvc$"))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") cells jolt-conj c) (jolt-invoke (var-deref "clojure.core" "str") "(or " c " (let ((_f " dv ")) (set! " c " _f) _f))"))) dv))) (let* ((_a$7886 (var-deref "clojure.core" "str")) (_a$7887 "(let* ((") (_a$7888 r) (_a$7889 " ") (_a$7890 (jolt-first as)) (_a$7891 ")) (") (_a$7892 resolver) (_a$7893 " ") (_a$7894 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-cons r (jolt-rest as)))) (_a$7895 "))")) (jolt-invoke _a$7886 _a$7887 _a$7888 _a$7889 _a$7890 _a$7891 _a$7892 _a$7893 _a$7894 _a$7895)))))) (if (jolt-truthy? (jolt-get node (keyword #f "num-kind"))) (let* ((_a$7896 (var-deref "jolt.backend-scheme" "emit-numeric")) (_a$7897 (jolt-get node (keyword #f "num-kind"))) (_a$7898 (jolt-get fnode (keyword #f "name"))) (_a$7899 args) (_a$7900 order-args)) (jolt-invoke _a$7896 _a$7897 _a$7898 _a$7899 _a$7900)) (if (jolt-truthy? (let* ((and__25__auto nop)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-empty? args))) (if (jolt-truthy? and__25__auto) (jolt= nop "+") and__25__auto)) and__25__auto))) "0" (if (jolt-truthy? (let* ((and__25__auto nop)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-empty? args))) (if (jolt-truthy? and__25__auto) (jolt= nop "*") and__25__auto)) and__25__auto))) "1" (if (jolt-truthy? (let* ((and__25__auto nop)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= 1 (jolt-count args)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.backend-scheme" "cmp1-ops") nop) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "clojure.core" "str") "(begin " (jolt-first args) " #t)") (if (jolt-truthy? nop) (jolt-invoke order-args (lambda (as) (let fnrec7901 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" nop " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")")))) (if (jolt= kind (keyword #f "keyword")) (let* ((recv (jolt-first arg-nodes)) (idx (if (let* ((and__25__auto (jolt= (keyword #f "struct") (jolt-get recv (keyword #f "hint"))))) (if (jolt-truthy? and__25__auto) (jolt= 1 (jolt-count arg-nodes)) and__25__auto)) (let* ((_a$7902 (var-deref "jolt.backend-scheme" "struct-field-index")) (_a$7903 (jolt-get recv (keyword #f "shape"))) (_a$7904 (jolt-get fnode (keyword #f "val")))) (jolt-invoke _a$7902 _a$7903 _a$7904)) jolt-nil))) (if (jolt-truthy? idx) (jolt-invoke order-args (lambda (as) (let fnrec7905 ((as as)) (let* ((_a$7906 (var-deref "clojure.core" "str")) (_a$7907 "(jrec-field-at ") (_a$7908 (jolt-first as)) (_a$7909 " ") (_a$7910 idx) (_a$7911 " ") (_a$7912 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode)) (_a$7913 ")")) (jolt-invoke _a$7906 _a$7907 _a$7908 _a$7909 _a$7910 _a$7911 _a$7912 _a$7913))))) (jolt-invoke order-args (lambda (as) (let fnrec7914 ((as as)) (let* ((_a$7915 (var-deref "clojure.core" "str")) (_a$7916 "(jolt-get ") (_a$7917 (jolt-first as)) (_a$7918 " ") (_a$7919 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode)) (_a$7920 (jolt-invoke defstr as)) (_a$7921 ")")) (jolt-invoke _a$7915 _a$7916 _a$7917 _a$7918 _a$7919 _a$7920 _a$7921))))))) (if (jolt= kind (keyword #f "coll")) (let* ((_a$7923 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7924 (jolt-cons fnode arg-nodes)) (_a$7925 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$7926 (lambda (G__145) (let fnrec7922 ((G__145 G__145)) (let* ((G__146 G__145) (c (jolt-nth G__146 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__146 1))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-get " c " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")")))))) (jolt-invoke _a$7923 _a$7924 _a$7925 _a$7926)) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.backend-scheme" "stdlib-var?") fnode))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "prelude-mode?"))) and__25__auto))) (jolt-throw (let* ((_a$7933 (let* ((_a$7927 (var-deref "clojure.core" "str")) (_a$7928 "emit: unsupported stdlib fn `") (_a$7929 (jolt-get fnode (keyword #f "ns"))) (_a$7930 "/") (_a$7931 (jolt-get fnode (keyword #f "name"))) (_a$7932 "` (no core on Chez yet)")) (jolt-invoke _a$7927 _a$7928 _a$7929 _a$7930 _a$7931 _a$7932))) (_a$7934 (jolt-hash-map))) (jolt-ex-info _a$7933 _a$7934))) (if (jolt= (keyword #f "host-static") (jolt-get fnode (keyword #f "op"))) (jolt-invoke order-args (lambda (as) (let fnrec7935 ((as as)) (let* ((_a$7936 (var-deref "clojure.core" "str")) (_a$7937 "(host-static-call ") (_a$7938 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "class")))) (_a$7939 " ") (_a$7940 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "member")))) (_a$7941 (if (jolt-empty? as) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)))) (_a$7942 ")")) (jolt-invoke _a$7936 _a$7937 _a$7938 _a$7939 _a$7940 _a$7941 _a$7942))))) (if (jolt= (keyword #f "host") (jolt-get fnode (keyword #f "op"))) (jolt-throw (let* ((_a$7943 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host call `" (jolt-get fnode (keyword #f "name")) "`")) (_a$7944 (jolt-hash-map))) (jolt-ex-info _a$7943 _a$7944))) (if (jolt= (keyword #f "local") (jolt-get fnode (keyword #f "op"))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "*known-procs*") (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get fnode (keyword #f "name"))))) (jolt-invoke order-args (lambda (as) (let fnrec7945 ((as as)) (let* ((_a$7946 (var-deref "clojure.core" "str")) (_a$7947 "(") (_a$7948 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get fnode (keyword #f "name")))) (_a$7949 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$7950 ")")) (jolt-invoke _a$7946 _a$7947 _a$7948 _a$7949 _a$7950))))) (jolt-invoke invoke)) (if (jolt-truthy? (let* ((and__25__auto (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (let* ((_a$7951 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$7952 (jolt-get fnode (keyword #f "ns"))) (_a$7953 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7951 _a$7952 _a$7953)))) (if (jolt-truthy? and__25__auto) (let* ((_a$7954 (var-deref "jolt.backend-scheme" "direct-link-fn?")) (_a$7955 (jolt-get fnode (keyword #f "ns"))) (_a$7956 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7954 _a$7955 _a$7956)) and__25__auto)) and__25__auto))) (jolt-invoke order-args (lambda (as) (let fnrec7957 ((as as)) (let* ((_a$7961 (var-deref "clojure.core" "str")) (_a$7962 "(") (_a$7963 (let* ((_a$7958 (var-deref "jolt.backend-scheme" "dl-name")) (_a$7959 (jolt-get fnode (keyword #f "ns"))) (_a$7960 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7958 _a$7959 _a$7960))) (_a$7964 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$7965 ")")) (jolt-invoke _a$7961 _a$7962 _a$7963 _a$7964 _a$7965))))) (if (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))) (jolt-invoke invoke) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke invoke) jolt-nil)))))))))))))))))))) emit-invoke) (let* ((_o$7966 (keyword #f "private")) (_o$7967 #t)) (jolt-hash-map _o$7966 _o$7967)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-invoke" (letrec ((emit-invoke (lambda (node) (let fnrec7901 ((node node)) (let* ((fnode (jolt-get node (keyword #f "fn"))) (arg-nodes (jolt-get node (keyword #f "args"))) (args (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit") arg-nodes)) (nop (jolt-invoke (var-deref "jolt.backend-scheme" "native-op") fnode (jolt-count args))) (kind (jolt-invoke (var-deref "jolt.backend-scheme" "ifn-kind") fnode)) (order-args (lambda (build) (let fnrec7902 ((build build)) (jolt-invoke (var-deref "jolt.backend-scheme" "ordered-call") arg-nodes args build)))) (defstr (lambda (as) (let fnrec7903 ((as as)) (if (> (jolt-count as) 1) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-nth as 1)) "")))) (invoke (lambda () (let fnrec7904 () (let* ((_a$7906 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7907 (jolt-cons fnode arg-nodes)) (_a$7908 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$7909 (lambda (G__143) (let fnrec7905 ((G__143 G__143)) (let* ((G__144 G__143) (f (jolt-nth G__144 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__144 1))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-invoke " f (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "") ")")))))) (jolt-invoke _a$7906 _a$7907 _a$7908 _a$7909)))))) (if (jolt-truthy? (jolt-get node (keyword #f "devirt-type"))) (jolt-invoke order-args (lambda (as) (let fnrec7910 ((as as)) (let* ((r (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_r$")) (dv (let* ((_a$7911 (var-deref "clojure.core" "str")) (_a$7912 "(devirt-resolve ") (_a$7913 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-type")))) (_a$7914 " ") (_a$7915 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-proto")))) (_a$7916 " ") (_a$7917 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-method")))) (_a$7918 " ") (_a$7919 r) (_a$7920 ")")) (jolt-invoke _a$7911 _a$7912 _a$7913 _a$7914 _a$7915 _a$7916 _a$7917 _a$7918 _a$7919 _a$7920))) (cells (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "devirt-cells"))) (resolver (if (jolt-truthy? cells) (let* ((c (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_dvc$"))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") cells jolt-conj c) (jolt-invoke (var-deref "clojure.core" "str") "(or " c " (let ((_f " dv ")) (set! " c " _f) _f))"))) dv))) (let* ((_a$7921 (var-deref "clojure.core" "str")) (_a$7922 "(let* ((") (_a$7923 r) (_a$7924 " ") (_a$7925 (jolt-first as)) (_a$7926 ")) (") (_a$7927 resolver) (_a$7928 " ") (_a$7929 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-cons r (jolt-rest as)))) (_a$7930 "))")) (jolt-invoke _a$7921 _a$7922 _a$7923 _a$7924 _a$7925 _a$7926 _a$7927 _a$7928 _a$7929 _a$7930)))))) (if (jolt-truthy? (jolt-get node (keyword #f "num-kind"))) (let* ((_a$7931 (var-deref "jolt.backend-scheme" "emit-numeric")) (_a$7932 (jolt-get node (keyword #f "num-kind"))) (_a$7933 (jolt-get fnode (keyword #f "name"))) (_a$7934 args) (_a$7935 order-args)) (jolt-invoke _a$7931 _a$7932 _a$7933 _a$7934 _a$7935)) (if (jolt-truthy? (let* ((and__25__auto nop)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-empty? args))) (if (jolt-truthy? and__25__auto) (jolt= nop "+") and__25__auto)) and__25__auto))) "0" (if (jolt-truthy? (let* ((and__25__auto nop)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-empty? args))) (if (jolt-truthy? and__25__auto) (jolt= nop "*") and__25__auto)) and__25__auto))) "1" (if (jolt-truthy? (let* ((and__25__auto nop)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= 1 (jolt-count args)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.backend-scheme" "cmp1-ops") nop) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "clojure.core" "str") "(begin " (jolt-first args) " #t)") (if (jolt-truthy? nop) (jolt-invoke order-args (lambda (as) (let fnrec7936 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" nop " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")")))) (if (jolt= kind (keyword #f "keyword")) (let* ((recv (jolt-first arg-nodes)) (idx (if (let* ((and__25__auto (jolt= (keyword #f "struct") (jolt-get recv (keyword #f "hint"))))) (if (jolt-truthy? and__25__auto) (jolt= 1 (jolt-count arg-nodes)) and__25__auto)) (let* ((_a$7937 (var-deref "jolt.backend-scheme" "struct-field-index")) (_a$7938 (jolt-get recv (keyword #f "shape"))) (_a$7939 (jolt-get fnode (keyword #f "val")))) (jolt-invoke _a$7937 _a$7938 _a$7939)) jolt-nil))) (if (jolt-truthy? idx) (jolt-invoke order-args (lambda (as) (let fnrec7940 ((as as)) (let* ((_a$7941 (var-deref "clojure.core" "str")) (_a$7942 "(jrec-field-at ") (_a$7943 (jolt-first as)) (_a$7944 " ") (_a$7945 idx) (_a$7946 " ") (_a$7947 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode)) (_a$7948 ")")) (jolt-invoke _a$7941 _a$7942 _a$7943 _a$7944 _a$7945 _a$7946 _a$7947 _a$7948))))) (jolt-invoke order-args (lambda (as) (let fnrec7949 ((as as)) (let* ((_a$7950 (var-deref "clojure.core" "str")) (_a$7951 "(jolt-get ") (_a$7952 (jolt-first as)) (_a$7953 " ") (_a$7954 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode)) (_a$7955 (jolt-invoke defstr as)) (_a$7956 ")")) (jolt-invoke _a$7950 _a$7951 _a$7952 _a$7953 _a$7954 _a$7955 _a$7956))))))) (if (jolt= kind (keyword #f "coll")) (let* ((_a$7958 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7959 (jolt-cons fnode arg-nodes)) (_a$7960 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$7961 (lambda (G__145) (let fnrec7957 ((G__145 G__145)) (let* ((G__146 G__145) (c (jolt-nth G__146 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__146 1))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-get " c " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")")))))) (jolt-invoke _a$7958 _a$7959 _a$7960 _a$7961)) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.backend-scheme" "stdlib-var?") fnode))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "prelude-mode?"))) and__25__auto))) (jolt-throw (let* ((_a$7968 (let* ((_a$7962 (var-deref "clojure.core" "str")) (_a$7963 "emit: unsupported stdlib fn `") (_a$7964 (jolt-get fnode (keyword #f "ns"))) (_a$7965 "/") (_a$7966 (jolt-get fnode (keyword #f "name"))) (_a$7967 "` (no core on Chez yet)")) (jolt-invoke _a$7962 _a$7963 _a$7964 _a$7965 _a$7966 _a$7967))) (_a$7969 (jolt-hash-map))) (jolt-ex-info _a$7968 _a$7969))) (if (jolt= (keyword #f "host-static") (jolt-get fnode (keyword #f "op"))) (jolt-invoke order-args (lambda (as) (let fnrec7970 ((as as)) (let* ((_a$7971 (var-deref "clojure.core" "str")) (_a$7972 "(host-static-call ") (_a$7973 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "class")))) (_a$7974 " ") (_a$7975 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "member")))) (_a$7976 (if (jolt-empty? as) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)))) (_a$7977 ")")) (jolt-invoke _a$7971 _a$7972 _a$7973 _a$7974 _a$7975 _a$7976 _a$7977))))) (if (jolt= (keyword #f "host") (jolt-get fnode (keyword #f "op"))) (jolt-throw (let* ((_a$7978 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host call `" (jolt-get fnode (keyword #f "name")) "`")) (_a$7979 (jolt-hash-map))) (jolt-ex-info _a$7978 _a$7979))) (if (jolt= (keyword #f "local") (jolt-get fnode (keyword #f "op"))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "*known-procs*") (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get fnode (keyword #f "name"))))) (jolt-invoke order-args (lambda (as) (let fnrec7980 ((as as)) (let* ((_a$7981 (var-deref "clojure.core" "str")) (_a$7982 "(") (_a$7983 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get fnode (keyword #f "name")))) (_a$7984 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$7985 ")")) (jolt-invoke _a$7981 _a$7982 _a$7983 _a$7984 _a$7985))))) (jolt-invoke invoke)) (if (jolt-truthy? (let* ((and__25__auto (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (let* ((_a$7986 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$7987 (jolt-get fnode (keyword #f "ns"))) (_a$7988 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7986 _a$7987 _a$7988)))) (if (jolt-truthy? and__25__auto) (let* ((_a$7989 (var-deref "jolt.backend-scheme" "direct-link-fn?")) (_a$7990 (jolt-get fnode (keyword #f "ns"))) (_a$7991 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7989 _a$7990 _a$7991)) and__25__auto)) and__25__auto))) (jolt-invoke order-args (lambda (as) (let fnrec7992 ((as as)) (let* ((_a$7996 (var-deref "clojure.core" "str")) (_a$7997 "(") (_a$7998 (let* ((_a$7993 (var-deref "jolt.backend-scheme" "dl-name")) (_a$7994 (jolt-get fnode (keyword #f "ns"))) (_a$7995 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7993 _a$7994 _a$7995))) (_a$7999 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$8000 ")")) (jolt-invoke _a$7996 _a$7997 _a$7998 _a$7999 _a$8000))))) (if (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))) (jolt-invoke invoke) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke invoke) jolt-nil)))))))))))))))))))) emit-invoke) (let* ((_o$8001 (keyword #f "private")) (_o$8002 #t)) (jolt-hash-map _o$8001 _o$8002)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-try" (letrec ((emit-try (lambda (node) (let fnrec7968 ((node node)) (let* ((core (let* ((temp__16__auto (jolt-get node (keyword #f "catch-sym")))) (if (jolt-truthy? temp__16__auto) (let* ((cs temp__16__auto)) (let* ((_a$7969 (var-deref "clojure.core" "str")) (_a$7970 "(guard (") (_a$7971 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") cs)) (_a$7972 " (else ") (_a$7973 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "catch-body")))) (_a$7974 ")) ") (_a$7975 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$7976 ")")) (jolt-invoke _a$7969 _a$7970 _a$7971 _a$7972 _a$7973 _a$7974 _a$7975 _a$7976))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body"))))))) (let* ((temp__16__auto (jolt-get node (keyword #f "finally")))) (if (jolt-truthy? temp__16__auto) (let* ((fin temp__16__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(dynamic-wind (lambda () #f) (lambda () " core ") (lambda () " (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fin) "))")) core))))))) emit-try) (let* ((_o$7977 (keyword #f "private")) (_o$7978 #t)) (jolt-hash-map _o$7977 _o$7978)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-try" (letrec ((emit-try (lambda (node) (let fnrec8003 ((node node)) (let* ((core (let* ((temp__16__auto (jolt-get node (keyword #f "catch-sym")))) (if (jolt-truthy? temp__16__auto) (let* ((cs temp__16__auto)) (let* ((_a$8004 (var-deref "clojure.core" "str")) (_a$8005 "(guard (") (_a$8006 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") cs)) (_a$8007 " (else ") (_a$8008 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "catch-body")))) (_a$8009 ")) ") (_a$8010 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$8011 ")")) (jolt-invoke _a$8004 _a$8005 _a$8006 _a$8007 _a$8008 _a$8009 _a$8010 _a$8011))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body"))))))) (let* ((temp__16__auto (jolt-get node (keyword #f "finally")))) (if (jolt-truthy? temp__16__auto) (let* ((fin temp__16__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(dynamic-wind (lambda () #f) (lambda () " core ") (lambda () " (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fin) "))")) core))))))) emit-try) (let* ((_o$8012 (keyword #f "private")) (_o$8013 #t)) (jolt-hash-map _o$8012 _o$8013)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "returns-scheme-bool?" (letrec ((returns-scheme-bool? (case-lambda ((node) (let fnrec7979 ((node node)) (returns-scheme-bool? node (jolt-hash-set)))) ((node bools) (let fnrec7980 ((node node) (bools bools)) (if (jolt-truthy? (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get node (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "boolean?") (jolt-get node (keyword #f "val"))) and__25__auto))) #t (if (jolt= (keyword #f "invoke") (jolt-get node (keyword #f "op"))) (let* ((nop (let* ((_a$7981 (var-deref "jolt.backend-scheme" "native-op")) (_a$7982 (jolt-get node (keyword #f "fn"))) (_a$7983 (jolt-count (jolt-get node (keyword #f "args"))))) (jolt-invoke _a$7981 _a$7982 _a$7983)))) (jolt-invoke (var-deref "clojure.core" "boolean") (let* ((and__25__auto nop)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.backend-scheme" "bool-returning-ops") nop) and__25__auto)))) (if (jolt= (keyword #f "local") (jolt-get node (keyword #f "op"))) (jolt-contains? bools (jolt-get node (keyword #f "name"))) (if (jolt= (keyword #f "if") (jolt-get node (keyword #f "op"))) (let* ((and__25__auto (returns-scheme-bool? (jolt-get node (keyword #f "then")) bools))) (if (jolt-truthy? and__25__auto) (returns-scheme-bool? (jolt-get node (keyword #f "else")) bools) and__25__auto)) (if (jolt= (keyword #f "let") (jolt-get node (keyword #f "op"))) (let* ((bools_PRIME_ (let* ((_a$7985 (lambda (s b) (let fnrec7984 ((s s) (b b)) (if (jolt-truthy? (returns-scheme-bool? (jolt-nth b 1) s)) (jolt-conj s (jolt-nth b 0)) (jolt-invoke (var-deref "clojure.core" "disj") s (jolt-nth b 0)))))) (_a$7986 bools) (_a$7987 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$7985 _a$7986 _a$7987)))) (returns-scheme-bool? (jolt-get node (keyword #f "body")) bools_PRIME_)) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))))))))) returns-scheme-bool?) (let* ((_o$7988 (keyword #f "private")) (_o$7989 #t)) (jolt-hash-map _o$7988 _o$7989)))) + (def-var-with-meta! "jolt.backend-scheme" "returns-scheme-bool?" (letrec ((returns-scheme-bool? (case-lambda ((node) (let fnrec8014 ((node node)) (returns-scheme-bool? node (jolt-hash-set)))) ((node bools) (let fnrec8015 ((node node) (bools bools)) (if (jolt-truthy? (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get node (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "boolean?") (jolt-get node (keyword #f "val"))) and__25__auto))) #t (if (jolt= (keyword #f "invoke") (jolt-get node (keyword #f "op"))) (let* ((nop (let* ((_a$8016 (var-deref "jolt.backend-scheme" "native-op")) (_a$8017 (jolt-get node (keyword #f "fn"))) (_a$8018 (jolt-count (jolt-get node (keyword #f "args"))))) (jolt-invoke _a$8016 _a$8017 _a$8018)))) (jolt-invoke (var-deref "clojure.core" "boolean") (let* ((and__25__auto nop)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.backend-scheme" "bool-returning-ops") nop) and__25__auto)))) (if (jolt= (keyword #f "local") (jolt-get node (keyword #f "op"))) (jolt-contains? bools (jolt-get node (keyword #f "name"))) (if (jolt= (keyword #f "if") (jolt-get node (keyword #f "op"))) (let* ((and__25__auto (returns-scheme-bool? (jolt-get node (keyword #f "then")) bools))) (if (jolt-truthy? and__25__auto) (returns-scheme-bool? (jolt-get node (keyword #f "else")) bools) and__25__auto)) (if (jolt= (keyword #f "let") (jolt-get node (keyword #f "op"))) (let* ((bools_PRIME_ (let* ((_a$8020 (lambda (s b) (let fnrec8019 ((s s) (b b)) (if (jolt-truthy? (returns-scheme-bool? (jolt-nth b 1) s)) (jolt-conj s (jolt-nth b 0)) (jolt-invoke (var-deref "clojure.core" "disj") s (jolt-nth b 0)))))) (_a$8021 bools) (_a$8022 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$8020 _a$8021 _a$8022)))) (returns-scheme-bool? (jolt-get node (keyword #f "body")) bools_PRIME_)) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))))))))) returns-scheme-bool?) (let* ((_o$8023 (keyword #f "private")) (_o$8024 #t)) (jolt-hash-map _o$8023 _o$8024)))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit" (letrec ((emit (lambda (node) (let fnrec7990 ((node node)) (let* ((G__147 (jolt-get node (keyword #f "op")))) (if (jolt= G__147 (keyword #f "const")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") (jolt-get node (keyword #f "val"))) (if (jolt= G__147 (keyword #f "local")) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get node (keyword #f "name"))) (if (jolt= G__147 (keyword #f "var")) (let* ((core-proc (let* ((and__25__auto (jolt= "clojure.core" (jolt-get node (keyword #f "ns"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.backend-scheme" "core-value-procs") (jolt-get node (keyword #f "name"))) and__25__auto)))) (if (jolt-truthy? core-proc) core-proc (if (jolt-truthy? (let* ((_a$7991 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$7992 (jolt-get node (keyword #f "ns"))) (_a$7993 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$7991 _a$7992 _a$7993))) (let* ((_a$7994 (var-deref "jolt.backend-scheme" "dl-name")) (_a$7995 (jolt-get node (keyword #f "ns"))) (_a$7996 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$7994 _a$7995 _a$7996)) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.backend-scheme" "stdlib-var?") node))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "prelude-mode?"))) and__25__auto))) (jolt-throw (let* ((_a$8003 (let* ((_a$7997 (var-deref "clojure.core" "str")) (_a$7998 "emit: unsupported stdlib ref `") (_a$7999 (jolt-get node (keyword #f "ns"))) (_a$8000 "/") (_a$8001 (jolt-get node (keyword #f "name"))) (_a$8002 "` (no core on Chez yet)")) (jolt-invoke _a$7997 _a$7998 _a$7999 _a$8000 _a$8001 _a$8002))) (_a$8004 (jolt-hash-map))) (jolt-ex-info _a$8003 _a$8004))) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$8005 (var-deref "clojure.core" "str")) (_a$8006 "(var-deref ") (_a$8007 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8008 " ") (_a$8009 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8010 ")")) (jolt-invoke _a$8005 _a$8006 _a$8007 _a$8008 _a$8009 _a$8010)) jolt-nil))))) (if (jolt= G__147 (keyword #f "the-var")) (let* ((_a$8011 (var-deref "clojure.core" "str")) (_a$8012 "(jolt-var ") (_a$8013 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8014 " ") (_a$8015 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8016 ")")) (jolt-invoke _a$8011 _a$8012 _a$8013 _a$8014 _a$8015 _a$8016)) (if (jolt= G__147 (keyword #f "set-var")) (let* ((_a$8017 (var-deref "clojure.core" "str")) (_a$8018 "(jolt-var-set ") (_a$8019 (emit (jolt-get node (keyword #f "the-var")))) (_a$8020 " ") (_a$8021 (emit (jolt-get node (keyword #f "val")))) (_a$8022 ")")) (jolt-invoke _a$8017 _a$8018 _a$8019 _a$8020 _a$8021 _a$8022)) (if (jolt= G__147 (keyword #f "set-field")) (let* ((_a$8023 (var-deref "clojure.core" "str")) (_a$8024 "(jolt-set-field! ") (_a$8025 (emit (jolt-get node (keyword #f "obj")))) (_a$8026 " (keyword #f ") (_a$8027 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "field")))) (_a$8028 ") ") (_a$8029 (emit (jolt-get node (keyword #f "val")))) (_a$8030 ")")) (jolt-invoke _a$8023 _a$8024 _a$8025 _a$8026 _a$8027 _a$8028 _a$8029 _a$8030)) (if (jolt= G__147 (keyword #f "defmacro")) (let* ((_a$8031 (var-deref "clojure.core" "str")) (_a$8032 "(begin (def-var! ") (_a$8033 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8034 " ") (_a$8035 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8036 " ") (_a$8037 (emit (jolt-get node (keyword #f "fn")))) (_a$8038 ") (mark-macro! ") (_a$8039 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8040 " ") (_a$8041 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8042 ") jolt-nil)")) (jolt-invoke _a$8031 _a$8032 _a$8033 _a$8034 _a$8035 _a$8036 _a$8037 _a$8038 _a$8039 _a$8040 _a$8041 _a$8042)) (if (jolt= G__147 (keyword #f "host")) (jolt-throw (let* ((_a$8043 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host ref `" (jolt-get node (keyword #f "name")) "`")) (_a$8044 (jolt-hash-map))) (jolt-ex-info _a$8043 _a$8044))) (if (jolt= G__147 (keyword #f "host-static")) (let* ((_a$8045 (var-deref "clojure.core" "str")) (_a$8046 "(host-static-ref ") (_a$8047 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$8048 " ") (_a$8049 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "member")))) (_a$8050 ")")) (jolt-invoke _a$8045 _a$8046 _a$8047 _a$8048 _a$8049 _a$8050)) (if (jolt= G__147 (keyword #f "host-new")) (let* ((_a$8051 (var-deref "clojure.core" "str")) (_a$8052 "(host-new ") (_a$8053 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$8054 (let* ((args (jolt-map emit (jolt-get node (keyword #f "args"))))) (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args))))) (_a$8055 ")")) (jolt-invoke _a$8051 _a$8052 _a$8053 _a$8054 _a$8055)) (if (jolt= G__147 (keyword #f "if")) (let* ((test (jolt-get node (keyword #f "test"))) (t (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "returns-scheme-bool?") test)) (emit test) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-truthy? " (emit test) ")")))) (let* ((_a$8056 (var-deref "clojure.core" "str")) (_a$8057 "(if ") (_a$8058 t) (_a$8059 " ") (_a$8060 (emit (jolt-get node (keyword #f "then")))) (_a$8061 " ") (_a$8062 (emit (jolt-get node (keyword #f "else")))) (_a$8063 ")")) (jolt-invoke _a$8056 _a$8057 _a$8058 _a$8059 _a$8060 _a$8061 _a$8062 _a$8063))) (if (jolt= G__147 (keyword #f "do")) (let* ((_a$8064 (var-deref "clojure.core" "str")) (_a$8065 "(begin ") (_a$8066 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit (jolt-get node (keyword #f "statements"))))) (_a$8067 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$8068 (emit (jolt-get node (keyword #f "ret")))) (_a$8069 ")")) (jolt-invoke _a$8064 _a$8065 _a$8066 _a$8067 _a$8068 _a$8069)) (if (jolt= G__147 (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-invoke") node) (if (jolt= G__147 (keyword #f "vector")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-vector" (jolt-map emit (jolt-get node (keyword #f "items")))) (if (jolt= G__147 (keyword #f "set")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-hash-set" (jolt-map emit (jolt-get node (keyword #f "items")))) (if (jolt= G__147 (keyword #f "map")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-hash-map" (let* ((_a$8073 (var-deref "clojure.core" "mapcat")) (_a$8074 (lambda (p) (let fnrec8070 ((p p)) (let* ((_o$8071 (emit (jolt-nth p 0))) (_o$8072 (emit (jolt-nth p 1)))) (jolt-vector _o$8071 _o$8072))))) (_a$8075 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$8073 _a$8074 _a$8075))) (if (jolt= G__147 (keyword #f "quote")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get node (keyword #f "form"))) (if (jolt= G__147 (keyword #f "throw")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-throw " (emit (jolt-get node (keyword #f "expr"))) ")") (if (jolt= G__147 (keyword #f "coerce")) (let* ((e (emit (jolt-get node (keyword #f "expr"))))) (if (jolt= (keyword #f "double") (jolt-get node (keyword #f "kind"))) (jolt-invoke (var-deref "clojure.core" "str") "(exact->inexact " e ")") (if (jolt= (keyword #f "long") (jolt-get node (keyword #f "kind"))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt->fx " e ")") (if (jolt-truthy? (keyword #f "else")) e jolt-nil)))) (if (jolt= G__147 (keyword #f "try")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-try") node) (if (jolt= G__147 (keyword #f "regex")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-regex " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "source"))) ")") (if (jolt= G__147 (keyword #f "inst")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-inst-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "source"))) ")") (if (jolt= G__147 (keyword #f "uuid")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-uuid-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "source"))) ")") (if (jolt= G__147 (keyword #f "bigdec")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-bigdec-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "source"))) ")") (if (jolt= G__147 (keyword #f "the-ns")) (jolt-invoke (var-deref "clojure.core" "str") "(intern-ns! " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name"))) ")") (if (jolt= G__147 (keyword #f "host-call")) (let* ((m (jolt-get node (keyword #f "method"))) (target (emit (jolt-get node (keyword #f "target")))) (args (jolt-map emit (jolt-get node (keyword #f "args"))))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "supported-host-methods") m)) (let* ((_a$8076 (var-deref "clojure.core" "str")) (_a$8077 "(jolt-host-call ") (_a$8078 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$8079 " ") (_a$8080 target) (_a$8081 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$8082 ")")) (jolt-invoke _a$8076 _a$8077 _a$8078 _a$8079 _a$8080 _a$8081 _a$8082)) (let* ((_a$8083 (var-deref "clojure.core" "str")) (_a$8084 "(record-method-dispatch ") (_a$8085 target) (_a$8086 " ") (_a$8087 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$8088 " (jolt-vector") (_a$8089 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$8090 "))")) (jolt-invoke _a$8083 _a$8084 _a$8085 _a$8086 _a$8087 _a$8088 _a$8089 _a$8090)))) (if (jolt= G__147 (keyword #f "let")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-let") node) (if (jolt= G__147 (keyword #f "loop")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-loop") node) (if (jolt= G__147 (keyword #f "recur")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-recur") node) (if (jolt= G__147 (keyword #f "ffi-fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-fn") node) (if (jolt= G__147 (keyword #f "ffi-callable")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-callable") node) (if (jolt= G__147 (keyword #f "fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-fn") node) (if (jolt= G__147 (keyword #f "def")) (if (jolt-truthy? (jolt-get node (keyword #f "no-init"))) (let* ((_a$8091 (var-deref "clojure.core" "str")) (_a$8092 "(declare-var! ") (_a$8093 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8094 " ") (_a$8095 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8096 ")")) (jolt-invoke _a$8091 _a$8092 _a$8093 _a$8094 _a$8095 _a$8096)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$8097 (var-deref "clojure.core" "str")) (_a$8098 "(def-var-with-meta! ") (_a$8099 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8100 " ") (_a$8101 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8102 " ") (_a$8103 (emit (jolt-get node (keyword #f "init")))) (_a$8104 " ") (_a$8105 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$8106 ")")) (jolt-invoke _a$8097 _a$8098 _a$8099 _a$8100 _a$8101 _a$8102 _a$8103 _a$8104 _a$8105 _a$8106)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$8107 (var-deref "clojure.core" "str")) (_a$8108 "(def-var! ") (_a$8109 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8110 " ") (_a$8111 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8112 " ") (_a$8113 (emit (jolt-get node (keyword #f "init")))) (_a$8114 ")")) (jolt-invoke _a$8107 _a$8108 _a$8109 _a$8110 _a$8111 _a$8112 _a$8113 _a$8114)) jolt-nil))) (jolt-throw (let* ((_a$8115 (jolt-invoke (var-deref "clojure.core" "str") "emit: op not yet ported / unhandled: " (jolt-invoke (var-deref "clojure.core" "pr-str") (jolt-get node (keyword #f "op"))))) (_a$8116 (jolt-hash-map))) (jolt-ex-info _a$8115 _a$8116))))))))))))))))))))))))))))))))))))))))) emit))) + (def-var! "jolt.backend-scheme" "emit" (letrec ((emit (lambda (node) (let fnrec8025 ((node node)) (let* ((G__147 (jolt-get node (keyword #f "op")))) (if (jolt= G__147 (keyword #f "const")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") (jolt-get node (keyword #f "val"))) (if (jolt= G__147 (keyword #f "local")) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get node (keyword #f "name"))) (if (jolt= G__147 (keyword #f "var")) (let* ((core-proc (let* ((and__25__auto (jolt= "clojure.core" (jolt-get node (keyword #f "ns"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.backend-scheme" "core-value-procs") (jolt-get node (keyword #f "name"))) and__25__auto)))) (if (jolt-truthy? core-proc) core-proc (if (jolt-truthy? (let* ((_a$8026 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$8027 (jolt-get node (keyword #f "ns"))) (_a$8028 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$8026 _a$8027 _a$8028))) (let* ((_a$8029 (var-deref "jolt.backend-scheme" "dl-name")) (_a$8030 (jolt-get node (keyword #f "ns"))) (_a$8031 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$8029 _a$8030 _a$8031)) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.backend-scheme" "stdlib-var?") node))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "prelude-mode?"))) and__25__auto))) (jolt-throw (let* ((_a$8038 (let* ((_a$8032 (var-deref "clojure.core" "str")) (_a$8033 "emit: unsupported stdlib ref `") (_a$8034 (jolt-get node (keyword #f "ns"))) (_a$8035 "/") (_a$8036 (jolt-get node (keyword #f "name"))) (_a$8037 "` (no core on Chez yet)")) (jolt-invoke _a$8032 _a$8033 _a$8034 _a$8035 _a$8036 _a$8037))) (_a$8039 (jolt-hash-map))) (jolt-ex-info _a$8038 _a$8039))) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$8040 (var-deref "clojure.core" "str")) (_a$8041 "(var-deref ") (_a$8042 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8043 " ") (_a$8044 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8045 ")")) (jolt-invoke _a$8040 _a$8041 _a$8042 _a$8043 _a$8044 _a$8045)) jolt-nil))))) (if (jolt= G__147 (keyword #f "the-var")) (let* ((_a$8046 (var-deref "clojure.core" "str")) (_a$8047 "(jolt-var ") (_a$8048 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8049 " ") (_a$8050 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8051 ")")) (jolt-invoke _a$8046 _a$8047 _a$8048 _a$8049 _a$8050 _a$8051)) (if (jolt= G__147 (keyword #f "set-var")) (let* ((_a$8052 (var-deref "clojure.core" "str")) (_a$8053 "(jolt-var-set ") (_a$8054 (emit (jolt-get node (keyword #f "the-var")))) (_a$8055 " ") (_a$8056 (emit (jolt-get node (keyword #f "val")))) (_a$8057 ")")) (jolt-invoke _a$8052 _a$8053 _a$8054 _a$8055 _a$8056 _a$8057)) (if (jolt= G__147 (keyword #f "set-field")) (let* ((_a$8058 (var-deref "clojure.core" "str")) (_a$8059 "(jolt-set-field! ") (_a$8060 (emit (jolt-get node (keyword #f "obj")))) (_a$8061 " (keyword #f ") (_a$8062 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "field")))) (_a$8063 ") ") (_a$8064 (emit (jolt-get node (keyword #f "val")))) (_a$8065 ")")) (jolt-invoke _a$8058 _a$8059 _a$8060 _a$8061 _a$8062 _a$8063 _a$8064 _a$8065)) (if (jolt= G__147 (keyword #f "defmacro")) (let* ((_a$8066 (var-deref "clojure.core" "str")) (_a$8067 "(begin (def-var! ") (_a$8068 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8069 " ") (_a$8070 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8071 " ") (_a$8072 (emit (jolt-get node (keyword #f "fn")))) (_a$8073 ") (mark-macro! ") (_a$8074 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8075 " ") (_a$8076 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8077 ") jolt-nil)")) (jolt-invoke _a$8066 _a$8067 _a$8068 _a$8069 _a$8070 _a$8071 _a$8072 _a$8073 _a$8074 _a$8075 _a$8076 _a$8077)) (if (jolt= G__147 (keyword #f "host")) (jolt-throw (let* ((_a$8078 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host ref `" (jolt-get node (keyword #f "name")) "`")) (_a$8079 (jolt-hash-map))) (jolt-ex-info _a$8078 _a$8079))) (if (jolt= G__147 (keyword #f "host-static")) (let* ((_a$8080 (var-deref "clojure.core" "str")) (_a$8081 "(host-static-ref ") (_a$8082 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$8083 " ") (_a$8084 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "member")))) (_a$8085 ")")) (jolt-invoke _a$8080 _a$8081 _a$8082 _a$8083 _a$8084 _a$8085)) (if (jolt= G__147 (keyword #f "host-new")) (let* ((_a$8086 (var-deref "clojure.core" "str")) (_a$8087 "(host-new ") (_a$8088 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$8089 (let* ((args (jolt-map emit (jolt-get node (keyword #f "args"))))) (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args))))) (_a$8090 ")")) (jolt-invoke _a$8086 _a$8087 _a$8088 _a$8089 _a$8090)) (if (jolt= G__147 (keyword #f "if")) (let* ((test (jolt-get node (keyword #f "test"))) (t (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "returns-scheme-bool?") test)) (emit test) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-truthy? " (emit test) ")")))) (let* ((_a$8091 (var-deref "clojure.core" "str")) (_a$8092 "(if ") (_a$8093 t) (_a$8094 " ") (_a$8095 (emit (jolt-get node (keyword #f "then")))) (_a$8096 " ") (_a$8097 (emit (jolt-get node (keyword #f "else")))) (_a$8098 ")")) (jolt-invoke _a$8091 _a$8092 _a$8093 _a$8094 _a$8095 _a$8096 _a$8097 _a$8098))) (if (jolt= G__147 (keyword #f "do")) (let* ((_a$8099 (var-deref "clojure.core" "str")) (_a$8100 "(begin ") (_a$8101 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit (jolt-get node (keyword #f "statements"))))) (_a$8102 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$8103 (emit (jolt-get node (keyword #f "ret")))) (_a$8104 ")")) (jolt-invoke _a$8099 _a$8100 _a$8101 _a$8102 _a$8103 _a$8104)) (if (jolt= G__147 (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-invoke") node) (if (jolt= G__147 (keyword #f "vector")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-vector" (jolt-map emit (jolt-get node (keyword #f "items")))) (if (jolt= G__147 (keyword #f "set")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-hash-set" (jolt-map emit (jolt-get node (keyword #f "items")))) (if (jolt= G__147 (keyword #f "map")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-hash-map" (let* ((_a$8108 (var-deref "clojure.core" "mapcat")) (_a$8109 (lambda (p) (let fnrec8105 ((p p)) (let* ((_o$8106 (emit (jolt-nth p 0))) (_o$8107 (emit (jolt-nth p 1)))) (jolt-vector _o$8106 _o$8107))))) (_a$8110 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$8108 _a$8109 _a$8110))) (if (jolt= G__147 (keyword #f "quote")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get node (keyword #f "form"))) (if (jolt= G__147 (keyword #f "throw")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-throw " (emit (jolt-get node (keyword #f "expr"))) ")") (if (jolt= G__147 (keyword #f "coerce")) (let* ((e (emit (jolt-get node (keyword #f "expr"))))) (if (jolt= (keyword #f "double") (jolt-get node (keyword #f "kind"))) (jolt-invoke (var-deref "clojure.core" "str") "(exact->inexact " e ")") (if (jolt= (keyword #f "long") (jolt-get node (keyword #f "kind"))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt->fx " e ")") (if (jolt-truthy? (keyword #f "else")) e jolt-nil)))) (if (jolt= G__147 (keyword #f "try")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-try") node) (if (jolt= G__147 (keyword #f "regex")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-regex " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "source"))) ")") (if (jolt= G__147 (keyword #f "inst")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-inst-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "source"))) ")") (if (jolt= G__147 (keyword #f "uuid")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-uuid-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "source"))) ")") (if (jolt= G__147 (keyword #f "bigdec")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-bigdec-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "source"))) ")") (if (jolt= G__147 (keyword #f "the-ns")) (jolt-invoke (var-deref "clojure.core" "str") "(intern-ns! " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name"))) ")") (if (jolt= G__147 (keyword #f "host-call")) (let* ((m (jolt-get node (keyword #f "method"))) (target (emit (jolt-get node (keyword #f "target")))) (args (jolt-map emit (jolt-get node (keyword #f "args"))))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "supported-host-methods") m)) (let* ((_a$8111 (var-deref "clojure.core" "str")) (_a$8112 "(jolt-host-call ") (_a$8113 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$8114 " ") (_a$8115 target) (_a$8116 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$8117 ")")) (jolt-invoke _a$8111 _a$8112 _a$8113 _a$8114 _a$8115 _a$8116 _a$8117)) (let* ((_a$8118 (var-deref "clojure.core" "str")) (_a$8119 "(record-method-dispatch ") (_a$8120 target) (_a$8121 " ") (_a$8122 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$8123 " (jolt-vector") (_a$8124 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$8125 "))")) (jolt-invoke _a$8118 _a$8119 _a$8120 _a$8121 _a$8122 _a$8123 _a$8124 _a$8125)))) (if (jolt= G__147 (keyword #f "let")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-let") node) (if (jolt= G__147 (keyword #f "loop")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-loop") node) (if (jolt= G__147 (keyword #f "recur")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-recur") node) (if (jolt= G__147 (keyword #f "ffi-fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-fn") node) (if (jolt= G__147 (keyword #f "ffi-callable")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-callable") node) (if (jolt= G__147 (keyword #f "fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-fn") node) (if (jolt= G__147 (keyword #f "def")) (if (jolt-truthy? (jolt-get node (keyword #f "no-init"))) (let* ((_a$8126 (var-deref "clojure.core" "str")) (_a$8127 "(declare-var! ") (_a$8128 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8129 " ") (_a$8130 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8131 ")")) (jolt-invoke _a$8126 _a$8127 _a$8128 _a$8129 _a$8130 _a$8131)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$8132 (var-deref "clojure.core" "str")) (_a$8133 "(def-var-with-meta! ") (_a$8134 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8135 " ") (_a$8136 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8137 " ") (_a$8138 (emit (jolt-get node (keyword #f "init")))) (_a$8139 " ") (_a$8140 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$8141 ")")) (jolt-invoke _a$8132 _a$8133 _a$8134 _a$8135 _a$8136 _a$8137 _a$8138 _a$8139 _a$8140 _a$8141)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$8142 (var-deref "clojure.core" "str")) (_a$8143 "(def-var! ") (_a$8144 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8145 " ") (_a$8146 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8147 " ") (_a$8148 (emit (jolt-get node (keyword #f "init")))) (_a$8149 ")")) (jolt-invoke _a$8142 _a$8143 _a$8144 _a$8145 _a$8146 _a$8147 _a$8148 _a$8149)) jolt-nil))) (jolt-throw (let* ((_a$8150 (jolt-invoke (var-deref "clojure.core" "str") "emit: op not yet ported / unhandled: " (jolt-invoke (var-deref "clojure.core" "pr-str") (jolt-get node (keyword #f "op"))))) (_a$8151 (jolt-hash-map))) (jolt-ex-info _a$8150 _a$8151))))))))))))))))))))))))))))))))))))))))) emit))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "dl-opt-out?" (letrec ((dl-opt-out? (lambda (m) (let fnrec8117 ((m m)) (let* ((or__26__auto (jolt-get m (keyword #f "dynamic")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-get m (keyword #f "redef")))))))) dl-opt-out?) (let* ((_o$8118 (keyword #f "private")) (_o$8119 #t)) (jolt-hash-map _o$8118 _o$8119)))) + (def-var-with-meta! "jolt.backend-scheme" "dl-opt-out?" (letrec ((dl-opt-out? (lambda (m) (let fnrec8152 ((m m)) (let* ((or__26__auto (jolt-get m (keyword #f "dynamic")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-get m (keyword #f "redef")))))))) dl-opt-out?) (let* ((_o$8153 (keyword #f "private")) (_o$8154 #t)) (jolt-hash-map _o$8153 _o$8154)))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit-top-form" (letrec ((emit-top-form (lambda (node) (let fnrec8120 ((node node)) (if (jolt-not (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link?"))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") node) (if (jolt= (keyword #f "do") (jolt-get node (keyword #f "op"))) (let* ((_a$8121 (var-deref "clojure.core" "str")) (_a$8122 "(begin ") (_a$8123 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-top-form (jolt-get node (keyword #f "statements"))))) (_a$8124 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$8125 (emit-top-form (jolt-get node (keyword #f "ret")))) (_a$8126 ")")) (jolt-invoke _a$8121 _a$8122 _a$8123 _a$8124 _a$8125 _a$8126)) (if (let* ((and__25__auto (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-get node (keyword #f "no-init"))))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "jolt.backend-scheme" "dl-opt-out?") (jolt-get node (keyword #f "meta")))) and__25__auto)) and__25__auto)) (let* ((ns (jolt-get node (keyword #f "ns"))) (nm (jolt-get node (keyword #f "name"))) (b (jolt-invoke (var-deref "jolt.backend-scheme" "dl-name") ns nm)) (fn? (jolt= (keyword #f "fn") (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "op")))) (pos (jolt-get node (keyword #f "pos"))) (frame-name (if (jolt-truthy? fn?) (let* ((temp__16__auto (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "name")))) (if (jolt-truthy? temp__16__auto) (let* ((fnm temp__16__auto)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") fnm)) b)) jolt-nil)) (reg (if (jolt-truthy? (let* ((and__25__auto fn?)) (if (jolt-truthy? and__25__auto) pos and__25__auto))) (let* ((_a$8127 (var-deref "clojure.core" "str")) (_a$8128 " (jolt-register-source! ") (_a$8129 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") frame-name)) (_a$8130 " ") (_a$8131 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$8132 " ") (_a$8133 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$8134 " ") (_a$8135 (if (jolt-truthy? (jolt-get pos (keyword #f "file"))) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get pos (keyword #f "file"))) "jolt-nil")) (_a$8136 " ") (_a$8137 (let* ((or__26__auto (jolt-get pos (keyword #f "line")))) (if (jolt-truthy? or__26__auto) or__26__auto 0))) (_a$8138 ")")) (jolt-invoke _a$8127 _a$8128 _a$8129 _a$8130 _a$8131 _a$8132 _a$8133 _a$8134 _a$8135 _a$8136 _a$8137 _a$8138)) jolt-nil))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.backend-scheme" "direct-link-defined") jolt-conj (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm)) (if (jolt-truthy? fn?) (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.backend-scheme" "direct-link-fns") jolt-conj (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm)) jolt-nil) (let* ((cells (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))) (_ (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "devirt-cells") cells)) (raw (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "init")))) (_ (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "devirt-cells") jolt-nil)) (init (if (jolt-truthy? (jolt-seq (jolt-invoke (var-deref "clojure.core" "deref") cells))) (jolt-invoke (var-deref "clojure.core" "str") "(let (" (jolt-invoke (var-deref "clojure.string" "join") " " (let* ((_a$8140 (lambda (c) (let fnrec8139 ((c c)) (jolt-invoke (var-deref "clojure.core" "str") "(" c " #f)")))) (_a$8141 (jolt-invoke (var-deref "clojure.core" "deref") cells))) (jolt-map _a$8140 _a$8141))) ") " raw ")") raw))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$8142 (var-deref "clojure.core" "str")) (_a$8143 "(begin (define ") (_a$8144 b) (_a$8145 " ") (_a$8146 init) (_a$8147 ") (def-var-with-meta! ") (_a$8148 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$8149 " ") (_a$8150 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$8151 " ") (_a$8152 b) (_a$8153 " ") (_a$8154 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$8155 ")") (_a$8156 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$8157 ")")) (jolt-invoke _a$8142 _a$8143 _a$8144 _a$8145 _a$8146 _a$8147 _a$8148 _a$8149 _a$8150 _a$8151 _a$8152 _a$8153 _a$8154 _a$8155 _a$8156 _a$8157)) (let* ((_a$8158 (var-deref "clojure.core" "str")) (_a$8159 "(begin (define ") (_a$8160 b) (_a$8161 " ") (_a$8162 init) (_a$8163 ") (def-var! ") (_a$8164 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$8165 " ") (_a$8166 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$8167 " ") (_a$8168 b) (_a$8169 ")") (_a$8170 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$8171 ")")) (jolt-invoke _a$8158 _a$8159 _a$8160 _a$8161 _a$8162 _a$8163 _a$8164 _a$8165 _a$8166 _a$8167 _a$8168 _a$8169 _a$8170 _a$8171)))))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") node) jolt-nil)))))))) emit-top-form))) + (def-var! "jolt.backend-scheme" "emit-top-form" (letrec ((emit-top-form (lambda (node) (let fnrec8155 ((node node)) (if (jolt-not (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link?"))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") node) (if (jolt= (keyword #f "do") (jolt-get node (keyword #f "op"))) (let* ((_a$8156 (var-deref "clojure.core" "str")) (_a$8157 "(begin ") (_a$8158 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-top-form (jolt-get node (keyword #f "statements"))))) (_a$8159 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$8160 (emit-top-form (jolt-get node (keyword #f "ret")))) (_a$8161 ")")) (jolt-invoke _a$8156 _a$8157 _a$8158 _a$8159 _a$8160 _a$8161)) (if (let* ((and__25__auto (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-get node (keyword #f "no-init"))))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "jolt.backend-scheme" "dl-opt-out?") (jolt-get node (keyword #f "meta")))) and__25__auto)) and__25__auto)) (let* ((ns (jolt-get node (keyword #f "ns"))) (nm (jolt-get node (keyword #f "name"))) (b (jolt-invoke (var-deref "jolt.backend-scheme" "dl-name") ns nm)) (fn? (jolt= (keyword #f "fn") (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "op")))) (pos (jolt-get node (keyword #f "pos"))) (frame-name (if (jolt-truthy? fn?) (let* ((temp__16__auto (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "name")))) (if (jolt-truthy? temp__16__auto) (let* ((fnm temp__16__auto)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") fnm)) b)) jolt-nil)) (reg (if (jolt-truthy? (let* ((and__25__auto fn?)) (if (jolt-truthy? and__25__auto) pos and__25__auto))) (let* ((_a$8162 (var-deref "clojure.core" "str")) (_a$8163 " (jolt-register-source! ") (_a$8164 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") frame-name)) (_a$8165 " ") (_a$8166 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$8167 " ") (_a$8168 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$8169 " ") (_a$8170 (if (jolt-truthy? (jolt-get pos (keyword #f "file"))) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get pos (keyword #f "file"))) "jolt-nil")) (_a$8171 " ") (_a$8172 (let* ((or__26__auto (jolt-get pos (keyword #f "line")))) (if (jolt-truthy? or__26__auto) or__26__auto 0))) (_a$8173 ")")) (jolt-invoke _a$8162 _a$8163 _a$8164 _a$8165 _a$8166 _a$8167 _a$8168 _a$8169 _a$8170 _a$8171 _a$8172 _a$8173)) jolt-nil))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.backend-scheme" "direct-link-defined") jolt-conj (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm)) (if (jolt-truthy? fn?) (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.backend-scheme" "direct-link-fns") jolt-conj (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm)) jolt-nil) (let* ((cells (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))) (_ (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "devirt-cells") cells)) (raw (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "init")))) (_ (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "devirt-cells") jolt-nil)) (init (if (jolt-truthy? (jolt-seq (jolt-invoke (var-deref "clojure.core" "deref") cells))) (jolt-invoke (var-deref "clojure.core" "str") "(let (" (jolt-invoke (var-deref "clojure.string" "join") " " (let* ((_a$8175 (lambda (c) (let fnrec8174 ((c c)) (jolt-invoke (var-deref "clojure.core" "str") "(" c " #f)")))) (_a$8176 (jolt-invoke (var-deref "clojure.core" "deref") cells))) (jolt-map _a$8175 _a$8176))) ") " raw ")") raw))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$8177 (var-deref "clojure.core" "str")) (_a$8178 "(begin (define ") (_a$8179 b) (_a$8180 " ") (_a$8181 init) (_a$8182 ") (def-var-with-meta! ") (_a$8183 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$8184 " ") (_a$8185 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$8186 " ") (_a$8187 b) (_a$8188 " ") (_a$8189 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$8190 ")") (_a$8191 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$8192 ")")) (jolt-invoke _a$8177 _a$8178 _a$8179 _a$8180 _a$8181 _a$8182 _a$8183 _a$8184 _a$8185 _a$8186 _a$8187 _a$8188 _a$8189 _a$8190 _a$8191 _a$8192)) (let* ((_a$8193 (var-deref "clojure.core" "str")) (_a$8194 "(begin (define ") (_a$8195 b) (_a$8196 " ") (_a$8197 init) (_a$8198 ") (def-var! ") (_a$8199 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$8200 " ") (_a$8201 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$8202 " ") (_a$8203 b) (_a$8204 ")") (_a$8205 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$8206 ")")) (jolt-invoke _a$8193 _a$8194 _a$8195 _a$8196 _a$8197 _a$8198 _a$8199 _a$8200 _a$8201 _a$8202 _a$8203 _a$8204 _a$8205 _a$8206)))))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") node) jolt-nil)))))))) emit-top-form))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.fold" "foldable" (let* ((_o$8172 "+") (_o$8173 jolt-add) (_o$8174 "-") (_o$8175 jolt-sub) (_o$8176 "*") (_o$8177 jolt-mul) (_o$8178 "/") (_o$8179 jolt-div) (_o$8180 "<") (_o$8181 <) (_o$8182 ">") (_o$8183 >) (_o$8184 "<=") (_o$8185 <=) (_o$8186 ">=") (_o$8187 >=) (_o$8188 "=") (_o$8189 jolt=) (_o$8190 "inc") (_o$8191 jolt-inc) (_o$8192 "dec") (_o$8193 jolt-dec) (_o$8194 "mod") (_o$8195 modulo) (_o$8196 "rem") (_o$8197 remainder) (_o$8198 "quot") (_o$8199 quotient) (_o$8200 "bit-and") (_o$8201 (var-deref "clojure.core" "__bit-and")) (_o$8202 "bit-or") (_o$8203 (var-deref "clojure.core" "__bit-or")) (_o$8204 "bit-xor") (_o$8205 (var-deref "clojure.core" "__bit-xor"))) (jolt-hash-map _o$8172 _o$8173 _o$8174 _o$8175 _o$8176 _o$8177 _o$8178 _o$8179 _o$8180 _o$8181 _o$8182 _o$8183 _o$8184 _o$8185 _o$8186 _o$8187 _o$8188 _o$8189 _o$8190 _o$8191 _o$8192 _o$8193 _o$8194 _o$8195 _o$8196 _o$8197 _o$8198 _o$8199 _o$8200 _o$8201 _o$8202 _o$8203 _o$8204 _o$8205)) (let* ((_o$8206 (keyword #f "private")) (_o$8207 #t)) (jolt-hash-map _o$8206 _o$8207)))) + (def-var-with-meta! "jolt.passes.fold" "foldable" (let* ((_o$8207 "+") (_o$8208 jolt-add) (_o$8209 "-") (_o$8210 jolt-sub) (_o$8211 "*") (_o$8212 jolt-mul) (_o$8213 "/") (_o$8214 jolt-div) (_o$8215 "<") (_o$8216 <) (_o$8217 ">") (_o$8218 >) (_o$8219 "<=") (_o$8220 <=) (_o$8221 ">=") (_o$8222 >=) (_o$8223 "=") (_o$8224 jolt=) (_o$8225 "inc") (_o$8226 jolt-inc) (_o$8227 "dec") (_o$8228 jolt-dec) (_o$8229 "mod") (_o$8230 modulo) (_o$8231 "rem") (_o$8232 remainder) (_o$8233 "quot") (_o$8234 quotient) (_o$8235 "bit-and") (_o$8236 (var-deref "clojure.core" "__bit-and")) (_o$8237 "bit-or") (_o$8238 (var-deref "clojure.core" "__bit-or")) (_o$8239 "bit-xor") (_o$8240 (var-deref "clojure.core" "__bit-xor"))) (jolt-hash-map _o$8207 _o$8208 _o$8209 _o$8210 _o$8211 _o$8212 _o$8213 _o$8214 _o$8215 _o$8216 _o$8217 _o$8218 _o$8219 _o$8220 _o$8221 _o$8222 _o$8223 _o$8224 _o$8225 _o$8226 _o$8227 _o$8228 _o$8229 _o$8230 _o$8231 _o$8232 _o$8233 _o$8234 _o$8235 _o$8236 _o$8237 _o$8238 _o$8239 _o$8240)) (let* ((_o$8241 (keyword #f "private")) (_o$8242 #t)) (jolt-hash-map _o$8241 _o$8242)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.fold" "const?" (letrec ((const? (lambda (n) (let fnrec8208 ((n n)) (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))))) const?) (let* ((_o$8209 (keyword #f "private")) (_o$8210 #t)) (jolt-hash-map _o$8209 _o$8210)))) + (def-var-with-meta! "jolt.passes.fold" "const?" (letrec ((const? (lambda (n) (let fnrec8243 ((n n)) (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))))) const?) (let* ((_o$8244 (keyword #f "private")) (_o$8245 #t)) (jolt-hash-map _o$8244 _o$8245)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.fold" "const-num?" (letrec ((const-num? (lambda (n) (let fnrec8211 ((n n)) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "const?") n))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "number?") (jolt-get n (keyword #f "val"))) and__25__auto)))))) const-num?) (let* ((_o$8212 (keyword #f "private")) (_o$8213 #t)) (jolt-hash-map _o$8212 _o$8213)))) + (def-var-with-meta! "jolt.passes.fold" "const-num?" (letrec ((const-num? (lambda (n) (let fnrec8246 ((n n)) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "const?") n))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "number?") (jolt-get n (keyword #f "val"))) and__25__auto)))))) const-num?) (let* ((_o$8247 (keyword #f "private")) (_o$8248 #t)) (jolt-hash-map _o$8247 _o$8248)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.fold" "fold-fn" (letrec ((fold-fn (lambda (fnode) (let fnrec8214 ((fnode fnode)) (let* ((op (jolt-get fnode (keyword #f "op")))) (if (let* ((or__26__auto (let* ((and__25__auto (jolt= op (keyword #f "var")))) (if (jolt-truthy? and__25__auto) (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) and__25__auto)))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= op (keyword #f "host")))) (jolt-get (var-deref "jolt.passes.fold" "foldable") (jolt-get fnode (keyword #f "name"))) jolt-nil)))))) fold-fn) (let* ((_o$8215 (keyword #f "private")) (_o$8216 #t)) (jolt-hash-map _o$8215 _o$8216)))) + (def-var-with-meta! "jolt.passes.fold" "fold-fn" (letrec ((fold-fn (lambda (fnode) (let fnrec8249 ((fnode fnode)) (let* ((op (jolt-get fnode (keyword #f "op")))) (if (let* ((or__26__auto (let* ((and__25__auto (jolt= op (keyword #f "var")))) (if (jolt-truthy? and__25__auto) (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) and__25__auto)))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= op (keyword #f "host")))) (jolt-get (var-deref "jolt.passes.fold" "foldable") (jolt-get fnode (keyword #f "name"))) jolt-nil)))))) fold-fn) (let* ((_o$8250 (keyword #f "private")) (_o$8251 #t)) (jolt-hash-map _o$8250 _o$8251)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.fold" "const-fold" (letrec ((const-fold (lambda (node) (let fnrec8217 ((node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "invoke")) (let* ((n (jolt-invoke (var-deref "jolt.ir" "map-ir-children") const-fold node)) (ff (jolt-invoke (var-deref "jolt.passes.fold" "fold-fn") (jolt-get n (keyword #f "fn")))) (args (jolt-get n (keyword #f "args"))) (folded (if (jolt-truthy? (let* ((and__25__auto ff)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-pos? (jolt-count args)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "every?") (var-deref "jolt.passes.fold" "const-num?") args) and__25__auto)) and__25__auto))) (guard (_r$catch1570 (else (let* ((e _r$catch1570)) jolt-nil))) (let* ((_o$8219 (keyword #f "op")) (_o$8220 (keyword #f "const")) (_o$8221 (keyword #f "val")) (_o$8222 (jolt-apply ff (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (a) (let fnrec8218 ((a a)) (jolt-get a (keyword #f "val")))) args)))) (jolt-hash-map _o$8219 _o$8220 _o$8221 _o$8222))) jolt-nil))) (let* ((or__26__auto folded)) (if (jolt-truthy? or__26__auto) or__26__auto n))) (if (jolt= op (keyword #f "if")) (let* ((t (const-fold (jolt-get node (keyword #f "test"))))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.fold" "const?") t)) (if (let* ((or__26__auto (jolt-nil? (jolt-get t (keyword #f "val"))))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= #f (jolt-get t (keyword #f "val"))))) (const-fold (jolt-get node (keyword #f "else"))) (const-fold (jolt-get node (keyword #f "then")))) (let* ((_a$8223 node) (_a$8224 (keyword #f "test")) (_a$8225 t) (_a$8226 (keyword #f "then")) (_a$8227 (const-fold (jolt-get node (keyword #f "then")))) (_a$8228 (keyword #f "else")) (_a$8229 (const-fold (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$8223 _a$8224 _a$8225 _a$8226 _a$8227 _a$8228 _a$8229)))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") const-fold node) jolt-nil)))))))) const-fold) (let* ((_o$8230 (keyword #f "doc")) (_o$8231 "Bottom-up constant folding: a call of a foldable numeric fn whose args are\n all constant numbers becomes a constant; an if with a constant test becomes\n the taken branch.")) (jolt-hash-map _o$8230 _o$8231)))) + (def-var-with-meta! "jolt.passes.fold" "const-fold" (letrec ((const-fold (lambda (node) (let fnrec8252 ((node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "invoke")) (let* ((n (jolt-invoke (var-deref "jolt.ir" "map-ir-children") const-fold node)) (ff (jolt-invoke (var-deref "jolt.passes.fold" "fold-fn") (jolt-get n (keyword #f "fn")))) (args (jolt-get n (keyword #f "args"))) (folded (if (jolt-truthy? (let* ((and__25__auto ff)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-pos? (jolt-count args)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "every?") (var-deref "jolt.passes.fold" "const-num?") args) and__25__auto)) and__25__auto))) (guard (_r$catch1577 (else (let* ((e _r$catch1577)) jolt-nil))) (let* ((_o$8254 (keyword #f "op")) (_o$8255 (keyword #f "const")) (_o$8256 (keyword #f "val")) (_o$8257 (jolt-apply ff (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (a) (let fnrec8253 ((a a)) (jolt-get a (keyword #f "val")))) args)))) (jolt-hash-map _o$8254 _o$8255 _o$8256 _o$8257))) jolt-nil))) (let* ((or__26__auto folded)) (if (jolt-truthy? or__26__auto) or__26__auto n))) (if (jolt= op (keyword #f "if")) (let* ((t (const-fold (jolt-get node (keyword #f "test"))))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.fold" "const?") t)) (if (let* ((or__26__auto (jolt-nil? (jolt-get t (keyword #f "val"))))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= #f (jolt-get t (keyword #f "val"))))) (const-fold (jolt-get node (keyword #f "else"))) (const-fold (jolt-get node (keyword #f "then")))) (let* ((_a$8258 node) (_a$8259 (keyword #f "test")) (_a$8260 t) (_a$8261 (keyword #f "then")) (_a$8262 (const-fold (jolt-get node (keyword #f "then")))) (_a$8263 (keyword #f "else")) (_a$8264 (const-fold (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$8258 _a$8259 _a$8260 _a$8261 _a$8262 _a$8263 _a$8264)))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") const-fold node) jolt-nil)))))))) const-fold) (let* ((_o$8265 (keyword #f "doc")) (_o$8266 "Bottom-up constant folding: a call of a foldable numeric fn whose args are\n all constant numbers becomes a constant; an if with a constant test becomes\n the taken branch.")) (jolt-hash-map _o$8265 _o$8266)))) (guard (e (#t #f)) - (def-var! "jolt.passes.fold" "scalar-const?" (letrec ((scalar-const? (lambda (n) (let fnrec8232 ((n n)) (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((v (jolt-get n (keyword #f "val")))) (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "keyword?") v))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "string?") v))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "number?") v))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-invoke (var-deref "clojure.core" "boolean?") v)))))))) and__25__auto)))))) scalar-const?))) + (def-var! "jolt.passes.fold" "scalar-const?" (letrec ((scalar-const? (lambda (n) (let fnrec8267 ((n n)) (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((v (jolt-get n (keyword #f "val")))) (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "keyword?") v))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "string?") v))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "number?") v))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-invoke (var-deref "clojure.core" "boolean?") v)))))))) and__25__auto)))))) scalar-const?))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.fold" "kw-callee?" (letrec ((kw-callee? (lambda (fnode) (let fnrec8233 ((fnode fnode)) (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "keyword?") (jolt-get fnode (keyword #f "val"))) and__25__auto)))))) kw-callee?) (let* ((_o$8234 (keyword #f "doc")) (_o$8235 "True if fnode is a constant keyword used as a function head \x2014; the (:k m) form.")) (jolt-hash-map _o$8234 _o$8235)))) + (def-var-with-meta! "jolt.passes.fold" "kw-callee?" (letrec ((kw-callee? (lambda (fnode) (let fnrec8268 ((fnode fnode)) (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "keyword?") (jolt-get fnode (keyword #f "val"))) and__25__auto)))))) kw-callee?) (let* ((_o$8269 (keyword #f "doc")) (_o$8270 "True if fnode is a constant keyword used as a function head \x2014; the (:k m) form.")) (jolt-hash-map _o$8269 _o$8270)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.fold" "get-callee?" (letrec ((get-callee? (lambda (fnode) (let fnrec8236 ((fnode fnode)) (let* ((or__26__auto (let* ((and__25__auto (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))))) (if (jolt-truthy? and__25__auto) (jolt= "get" (jolt-get fnode (keyword #f "name"))) and__25__auto)) and__25__auto)))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((and__25__auto (jolt= (keyword #f "host") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt= "get" (jolt-get fnode (keyword #f "name"))) and__25__auto)))))))) get-callee?) (let* ((_o$8237 (keyword #f "doc")) (_o$8238 "True if fnode is the clojure.core/get (or host get) callee \x2014; the (get m k) form.")) (jolt-hash-map _o$8237 _o$8238)))) + (def-var-with-meta! "jolt.passes.fold" "get-callee?" (letrec ((get-callee? (lambda (fnode) (let fnrec8271 ((fnode fnode)) (let* ((or__26__auto (let* ((and__25__auto (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))))) (if (jolt-truthy? and__25__auto) (jolt= "get" (jolt-get fnode (keyword #f "name"))) and__25__auto)) and__25__auto)))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((and__25__auto (jolt= (keyword #f "host") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt= "get" (jolt-get fnode (keyword #f "name"))) and__25__auto)))))))) get-callee?) (let* ((_o$8272 (keyword #f "doc")) (_o$8273 "True if fnode is the clojure.core/get (or host get) callee \x2014; the (get m k) form.")) (jolt-hash-map _o$8272 _o$8273)))) (guard (e (#t #f)) (def-var-with-meta! "jolt.passes.numeric" "int-lit?" (letrec ((int-lit? (lambda (n) (let fnrec6602 ((n n)) (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((v (jolt-get n (keyword #f "val")))) (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "number?") v))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "integer?") v) and__25__auto))) and__25__auto)))))) int-lit?) (let* ((_o$6603 (keyword #f "private")) (_o$6604 #t)) (jolt-hash-map _o$6603 _o$6604)))) (guard (e (#t #f)) diff --git a/host/chez/seed/prelude.ss b/host/chez/seed/prelude.ss index 5500cfd..c79a956 100644 --- a/host/chez/seed/prelude.ss +++ b/host/chez/seed/prelude.ss @@ -539,11 +539,11 @@ (guard (e (#t #f)) (def-var! "clojure.core" "to-array-2d" (letrec ((to-array-2d (lambda (coll) (let fnrec4639 ((coll coll)) (jolt-invoke (var-deref "clojure.core" "to-array") (jolt-map (var-deref "clojure.core" "to-array") coll)))))) to-array-2d))) (guard (e (#t #f)) - (def-var! "clojure.core" "unchecked-byte" (letrec ((unchecked-byte (lambda (x) (let fnrec4640 ((x x)) (jolt-invoke (var-deref "clojure.core" "bit-and") (jolt-invoke (var-deref "clojure.core" "int") x) 255))))) unchecked-byte))) + (def-var! "clojure.core" "unchecked-byte" (letrec ((unchecked-byte (lambda (x) (let fnrec4640 ((x x)) (bitwise-and (jolt-invoke (var-deref "clojure.core" "int") x) 255))))) unchecked-byte))) (guard (e (#t #f)) - (def-var! "clojure.core" "unchecked-short" (letrec ((unchecked-short (lambda (x) (let fnrec4641 ((x x)) (jolt-invoke (var-deref "clojure.core" "bit-and") (jolt-invoke (var-deref "clojure.core" "int") x) 65535))))) unchecked-short))) + (def-var! "clojure.core" "unchecked-short" (letrec ((unchecked-short (lambda (x) (let fnrec4641 ((x x)) (bitwise-and (jolt-invoke (var-deref "clojure.core" "int") x) 65535))))) unchecked-short))) (guard (e (#t #f)) - (def-var! "clojure.core" "unchecked-char" (letrec ((unchecked-char (lambda (x) (let fnrec4642 ((x x)) (jolt-invoke (var-deref "clojure.core" "char") (jolt-invoke (var-deref "clojure.core" "bit-and") (jolt-invoke (var-deref "clojure.core" "int") x) 65535)))))) unchecked-char))) + (def-var! "clojure.core" "unchecked-char" (letrec ((unchecked-char (lambda (x) (let fnrec4642 ((x x)) (jolt-invoke (var-deref "clojure.core" "char") (bitwise-and (jolt-invoke (var-deref "clojure.core" "int") x) 65535)))))) unchecked-char))) (guard (e (#t #f)) (def-var! "clojure.core" "unchecked-float" (letrec ((unchecked-float (lambda (x) (let fnrec4643 ((x x)) (jolt-invoke (var-deref "clojure.core" "double") x))))) unchecked-float))) (guard (e (#t #f)) diff --git a/jolt-core/jolt/backend_scheme.clj b/jolt-core/jolt/backend_scheme.clj index 4a86238..7fa62a8 100644 --- a/jolt-core/jolt/backend_scheme.clj +++ b/jolt-core/jolt/backend_scheme.clj @@ -37,6 +37,16 @@ "even?" "jolt-even?" "odd?" "jolt-odd?" "pos?" "jolt-pos?" "neg?" "jolt-neg?" "zero?" "jolt-zero?" "identity" "jolt-identity" "nil?" "jolt-nil?" "some?" "jolt-some?" "ex-info" "jolt-ex-info" + ;; bit ops: and/or/xor/not are Chez bitwise primitives (inlined to native code, + ;; no helper call); operands must be integers (a non-integer errors, like the + ;; JVM). The shifts keep their helpers (Java >>> masking / arithmetic shift) but + ;; emit a direct call instead of var-deref + the variadic overlay. + ;; and/or/xor/not map to variadic Chez bitwise prims (safe as a value at any + ;; arity). bit-and-not is left to its overlay: its only Scheme impl is 2-arg, so + ;; a value-position arity-3 use (via the variadic overlay) would mis-emit. + "bit-and" "bitwise-and" "bit-or" "bitwise-ior" "bit-xor" "bitwise-xor" "bit-not" "bitwise-not" + "bit-shift-left" "jolt-bit-shift-left" "bit-shift-right" "jolt-bit-shift-right" + "unsigned-bit-shift-right" "jolt-unsigned-bit-shift-right" ;; positional protocol-method dispatch (defprotocol-emitted shims) — bind ;; directly to the records.ss entry points so a protocol call doesn't var-deref. "protocol-dispatch1" "protocol-dispatch1" "protocol-dispatch2" "protocol-dispatch2" @@ -66,7 +76,10 @@ "cons" #(= % 2) "filter" #(= % 2) "remove" #(= % 2) "into" #(= % 2) "take" #(= % 2) "drop" #(= % 2) "map" #(>= % 2) "apply" #(>= % 2) "reduce" #(or (= % 2) (= % 3)) "range" #(and (>= % 0) (<= % 3)) - "ex-info" #(or (= % 2) (= % 3))}) + "ex-info" #(or (= % 2) (= % 3)) + "bit-and" #(= % 2) "bit-or" #(= % 2) "bit-xor" #(= % 2) "bit-not" #(= % 1) + "bit-shift-left" #(= % 2) "bit-shift-right" #(= % 2) + "unsigned-bit-shift-right" #(= % 2)}) ;; jolt's comparison ops are vacuously true at arity 1 and DON'T inspect the arg, ;; but Scheme's < demands a number even there — special-case. diff --git a/test/chez/corpus.edn b/test/chez/corpus.edn index e178fe0..34cb06d 100644 --- a/test/chez/corpus.edn +++ b/test/chez/corpus.edn @@ -1545,6 +1545,11 @@ {:suite "numbers / variadic bit ops" :label "bit-and-not 3" :expected "8" :actual "(bit-and-not 12 6 3)"} {:suite "numbers / variadic bit ops" :label "bit-and single arg throws" :expected :throws :actual "(bit-and 5)"} {:suite "numbers / variadic bit ops" :label "bit-or keeps binary fast path" :expected "3" :actual "(bit-or 1 2)"} + {:suite "numbers / variadic bit ops" :label "bit-not" :expected "-6" :actual "(bit-not 5)"} + {:suite "numbers / variadic bit ops" :label "bit-and in value position" :expected "8" :actual "(reduce bit-and [15 9 12])"} + {:suite "numbers / variadic bit ops" :label "bit-xor in value position" :expected "0" :actual "(reduce bit-xor 0 [1 2 3])"} + {:suite "numbers / variadic bit ops" :label "bit-or via apply" :expected "7" :actual "(apply bit-or [1 2 4])"} + {:suite "numbers / variadic bit ops" :label "unsigned-shift over a full 64-bit value" :expected "17179869183" :actual "(unsigned-bit-shift-right -1 30)"} {:suite "predicates / nil & boolean" :label "nil? true" :expected "true" :actual "(nil? nil)"} {:suite "predicates / nil & boolean" :label "nil? false" :expected "false" :actual "(nil? 0)"} {:suite "predicates / nil & boolean" :label "some? true" :expected "true" :actual "(some? 0)"} From 04180c1e4eb19cfcfaa8a40497ca2440237ba7aa Mon Sep 17 00:00:00 2001 From: Yogthos Date: Sun, 28 Jun 2026 12:36:35 -0400 Subject: [PATCH 7/7] backend: cache resolved var cells per reference site (run-path ~5x) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Profiling jolt-i5if showed <=60-bit arithmetic is already native-fast; the real general overhead in the run/-e/-m path is var resolution. Every var reference compiled to (var-deref ns name), which builds + hashes a fresh "ns/name" string and does a hashtable lookup per access (~45ns). The var cell is interned and def-var! mutates it in place, so caching the resolved cell is sound under redefinition. Generalize the devirt per-site cache-cell mechanism to var value references: a ref inside a fn resolves its cell once into the def's closure, then reads it via var-cell-deref (a field read after the first). var-cell-deref is the cell-based var-deref — binding-aware (dynamic vars + *ns* still resolve) and lenient on an unbound root (a forward-declared var doesn't throw, unlike jolt-var-get). Gated by a runtime flag: ON for runtime-compiled code (compile-eval.ss), OFF for the seed mint and AOT build (emit-image.ss) so the seed stays a byte-fixpoint -- prelude.ss is unchanged, only image.ss picks up the new backend. ~5x on a var-ref-heavy loop (1058ms->205ms); ~1.2x on test.check (its generators are more deftype/dispatch-bound than var-deref-bound). No C/FFI. Corpus rows pin redefinition / dynamic binding / forward ref through a cached ref. make test + shakesmoke green, selfhost holds, SCI 211/218, certify 0-new. --- host/chez/compile-eval.ss | 6 + host/chez/dyn-binding.ss | 10 ++ host/chez/emit-image.ss | 5 + host/chez/seed/image.ss | 246 +++++++++++++++--------------- jolt-core/jolt/backend_scheme.clj | 136 +++++++++++------ test/chez/corpus.edn | 6 + 6 files changed, 245 insertions(+), 164 deletions(-) diff --git a/host/chez/compile-eval.ss b/host/chez/compile-eval.ss index 05d86c3..982de53 100644 --- a/host/chez/compile-eval.ss +++ b/host/chez/compile-eval.ss @@ -104,6 +104,12 @@ ;; is only for the bare -e subset with no prelude. Turn prelude mode on once, here, ;; so every analyze->emit on this spine sees the full core. ((var-deref "jolt.backend-scheme" "set-prelude-mode!") #t) +;; Cache resolved var cells per reference site in runtime-compiled code (the big +;; win for libraries / REPL code). emit-image.ss turns this back off so the seed +;; mint and AOT build stay byte-deterministic. Guarded: the flag is absent in an +;; older seed during the first re-mint pass. +(let ((scv (var-deref "jolt.backend-scheme" "set-var-cache!"))) + (when (procedure? scv) (scv #t))) ;; (quote X) -> X, else x — unwraps a quoted require spec. (define (ce-unquote x) diff --git a/host/chez/dyn-binding.ss b/host/chez/dyn-binding.ss index 5aad938..19be27c 100644 --- a/host/chez/dyn-binding.ss +++ b/host/chez/dyn-binding.ss @@ -117,6 +117,16 @@ ((eq? cell star-ns-cell) (intern-ns! (chez-current-ns))) (else (var-cell-root cell))))))) +;; var-deref's read on an ALREADY-RESOLVED cell — what compiled code emits when it +;; caches the cell at a reference site. Binding stack first, then *ns* thread-local, +;; else the raw root. Lenient on an unbound root (returns the sentinel), matching +;; var-deref — NOT the strict jolt-var-get, which throws "Unbound var". +(define (var-cell-deref cell) + (let ((bv (dyn-binding-value cell))) + (cond ((not (eq? bv dyn-no-binding)) bv) + ((eq? cell star-ns-cell) (intern-ns! (chez-current-ns))) + (else (var-cell-root cell))))) + ;; jolt-var-get (vars.ss): the var-get fn + deref/@ on a cell. Stack first, then ;; the original (which errors on an unbound root, matching Clojure). (define %dyn-var-get jolt-var-get) diff --git a/host/chez/emit-image.ss b/host/chez/emit-image.ss index adb6329..d67c69f 100644 --- a/host/chez/emit-image.ss +++ b/host/chez/emit-image.ss @@ -41,6 +41,11 @@ ;; top-level entry: in direct-link mode it binds jv$ for a top-level def; off ;; that mode (the minter, runtime eval) it is exactly emit, so output is unchanged. (define jolt-ce-emit-top (var-deref "jolt.backend-scheme" "emit-top-form")) +;; Seed mint and AOT build must stay byte-deterministic, so emit the image with var +;; cell-caching OFF (compile-eval.ss turned it on for runtime eval; this file loads +;; after it). Guarded for the first re-mint pass off an older seed. +(let ((scv (var-deref "jolt.backend-scheme" "set-var-cache!"))) + (when (procedure? scv) (scv #f))) (define (ei-compile-form ctx f optimize?) (let ((ir (jolt-ce-analyze ctx f))) (jolt-ce-emit-top (if optimize? (jolt-ce-run-passes ir ctx) ir)))) diff --git a/host/chez/seed/image.ss b/host/chez/seed/image.ss index 834a49d..08e8324 100644 --- a/host/chez/seed/image.ss +++ b/host/chez/seed/image.ss @@ -1,133 +1,133 @@ (guard (e (#t #f)) - (def-var! "jolt.ir" "const" (letrec ((const (lambda (v) (let fnrec8274 ((v v)) (let* ((_o$8275 (keyword #f "op")) (_o$8276 (keyword #f "const")) (_o$8277 (keyword #f "val")) (_o$8278 v)) (jolt-hash-map _o$8275 _o$8276 _o$8277 _o$8278)))))) const))) + (def-var! "jolt.ir" "const" (letrec ((const (lambda (v) (let fnrec8296 ((v v)) (let* ((_o$8297 (keyword #f "op")) (_o$8298 (keyword #f "const")) (_o$8299 (keyword #f "val")) (_o$8300 v)) (jolt-hash-map _o$8297 _o$8298 _o$8299 _o$8300)))))) const))) (guard (e (#t #f)) - (def-var! "jolt.ir" "local" (letrec ((local (lambda (name) (let fnrec8279 ((name name)) (let* ((_o$8280 (keyword #f "op")) (_o$8281 (keyword #f "local")) (_o$8282 (keyword #f "name")) (_o$8283 name)) (jolt-hash-map _o$8280 _o$8281 _o$8282 _o$8283)))))) local))) + (def-var! "jolt.ir" "local" (letrec ((local (lambda (name) (let fnrec8301 ((name name)) (let* ((_o$8302 (keyword #f "op")) (_o$8303 (keyword #f "local")) (_o$8304 (keyword #f "name")) (_o$8305 name)) (jolt-hash-map _o$8302 _o$8303 _o$8304 _o$8305)))))) local))) (guard (e (#t #f)) - (def-var! "jolt.ir" "var-ref" (letrec ((var-ref (lambda (ns name) (let fnrec8284 ((ns ns) (name name)) (let* ((_o$8285 (keyword #f "op")) (_o$8286 (keyword #f "var")) (_o$8287 (keyword #f "ns")) (_o$8288 ns) (_o$8289 (keyword #f "name")) (_o$8290 name)) (jolt-hash-map _o$8285 _o$8286 _o$8287 _o$8288 _o$8289 _o$8290)))))) var-ref))) + (def-var! "jolt.ir" "var-ref" (letrec ((var-ref (lambda (ns name) (let fnrec8306 ((ns ns) (name name)) (let* ((_o$8307 (keyword #f "op")) (_o$8308 (keyword #f "var")) (_o$8309 (keyword #f "ns")) (_o$8310 ns) (_o$8311 (keyword #f "name")) (_o$8312 name)) (jolt-hash-map _o$8307 _o$8308 _o$8309 _o$8310 _o$8311 _o$8312)))))) var-ref))) (guard (e (#t #f)) - (def-var! "jolt.ir" "the-var" (letrec ((the-var (lambda (ns name) (let fnrec8291 ((ns ns) (name name)) (let* ((_o$8292 (keyword #f "op")) (_o$8293 (keyword #f "the-var")) (_o$8294 (keyword #f "ns")) (_o$8295 ns) (_o$8296 (keyword #f "name")) (_o$8297 name)) (jolt-hash-map _o$8292 _o$8293 _o$8294 _o$8295 _o$8296 _o$8297)))))) the-var))) + (def-var! "jolt.ir" "the-var" (letrec ((the-var (lambda (ns name) (let fnrec8313 ((ns ns) (name name)) (let* ((_o$8314 (keyword #f "op")) (_o$8315 (keyword #f "the-var")) (_o$8316 (keyword #f "ns")) (_o$8317 ns) (_o$8318 (keyword #f "name")) (_o$8319 name)) (jolt-hash-map _o$8314 _o$8315 _o$8316 _o$8317 _o$8318 _o$8319)))))) the-var))) (guard (e (#t #f)) - (def-var! "jolt.ir" "host-ref" (letrec ((host-ref (lambda (name) (let fnrec8298 ((name name)) (let* ((_o$8299 (keyword #f "op")) (_o$8300 (keyword #f "host")) (_o$8301 (keyword #f "name")) (_o$8302 name)) (jolt-hash-map _o$8299 _o$8300 _o$8301 _o$8302)))))) host-ref))) + (def-var! "jolt.ir" "host-ref" (letrec ((host-ref (lambda (name) (let fnrec8320 ((name name)) (let* ((_o$8321 (keyword #f "op")) (_o$8322 (keyword #f "host")) (_o$8323 (keyword #f "name")) (_o$8324 name)) (jolt-hash-map _o$8321 _o$8322 _o$8323 _o$8324)))))) host-ref))) (guard (e (#t #f)) - (def-var! "jolt.ir" "host-static" (letrec ((host-static (lambda (class member) (let fnrec8303 ((class class) (member member)) (let* ((_o$8304 (keyword #f "op")) (_o$8305 (keyword #f "host-static")) (_o$8306 (keyword #f "class")) (_o$8307 class) (_o$8308 (keyword #f "member")) (_o$8309 member)) (jolt-hash-map _o$8304 _o$8305 _o$8306 _o$8307 _o$8308 _o$8309)))))) host-static))) + (def-var! "jolt.ir" "host-static" (letrec ((host-static (lambda (class member) (let fnrec8325 ((class class) (member member)) (let* ((_o$8326 (keyword #f "op")) (_o$8327 (keyword #f "host-static")) (_o$8328 (keyword #f "class")) (_o$8329 class) (_o$8330 (keyword #f "member")) (_o$8331 member)) (jolt-hash-map _o$8326 _o$8327 _o$8328 _o$8329 _o$8330 _o$8331)))))) host-static))) (guard (e (#t #f)) - (def-var! "jolt.ir" "host-new" (letrec ((host-new (lambda (class args) (let fnrec8310 ((class class) (args args)) (let* ((_o$8311 (keyword #f "op")) (_o$8312 (keyword #f "host-new")) (_o$8313 (keyword #f "class")) (_o$8314 class) (_o$8315 (keyword #f "args")) (_o$8316 args)) (jolt-hash-map _o$8311 _o$8312 _o$8313 _o$8314 _o$8315 _o$8316)))))) host-new))) + (def-var! "jolt.ir" "host-new" (letrec ((host-new (lambda (class args) (let fnrec8332 ((class class) (args args)) (let* ((_o$8333 (keyword #f "op")) (_o$8334 (keyword #f "host-new")) (_o$8335 (keyword #f "class")) (_o$8336 class) (_o$8337 (keyword #f "args")) (_o$8338 args)) (jolt-hash-map _o$8333 _o$8334 _o$8335 _o$8336 _o$8337 _o$8338)))))) host-new))) (guard (e (#t #f)) - (def-var! "jolt.ir" "if-node" (letrec ((if-node (lambda (test then _else) (let fnrec8317 ((test test) (then then) (_else _else)) (let* ((_o$8318 (keyword #f "op")) (_o$8319 (keyword #f "if")) (_o$8320 (keyword #f "test")) (_o$8321 test) (_o$8322 (keyword #f "then")) (_o$8323 then) (_o$8324 (keyword #f "else")) (_o$8325 _else)) (jolt-hash-map _o$8318 _o$8319 _o$8320 _o$8321 _o$8322 _o$8323 _o$8324 _o$8325)))))) if-node))) + (def-var! "jolt.ir" "if-node" (letrec ((if-node (lambda (test then _else) (let fnrec8339 ((test test) (then then) (_else _else)) (let* ((_o$8340 (keyword #f "op")) (_o$8341 (keyword #f "if")) (_o$8342 (keyword #f "test")) (_o$8343 test) (_o$8344 (keyword #f "then")) (_o$8345 then) (_o$8346 (keyword #f "else")) (_o$8347 _else)) (jolt-hash-map _o$8340 _o$8341 _o$8342 _o$8343 _o$8344 _o$8345 _o$8346 _o$8347)))))) if-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "do-node" (letrec ((do-node (lambda (statements ret) (let fnrec8326 ((statements statements) (ret ret)) (let* ((_o$8327 (keyword #f "op")) (_o$8328 (keyword #f "do")) (_o$8329 (keyword #f "statements")) (_o$8330 statements) (_o$8331 (keyword #f "ret")) (_o$8332 ret)) (jolt-hash-map _o$8327 _o$8328 _o$8329 _o$8330 _o$8331 _o$8332)))))) do-node))) + (def-var! "jolt.ir" "do-node" (letrec ((do-node (lambda (statements ret) (let fnrec8348 ((statements statements) (ret ret)) (let* ((_o$8349 (keyword #f "op")) (_o$8350 (keyword #f "do")) (_o$8351 (keyword #f "statements")) (_o$8352 statements) (_o$8353 (keyword #f "ret")) (_o$8354 ret)) (jolt-hash-map _o$8349 _o$8350 _o$8351 _o$8352 _o$8353 _o$8354)))))) do-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "invoke" (letrec ((invoke (lambda (f args) (let fnrec8333 ((f f) (args args)) (let* ((_o$8334 (keyword #f "op")) (_o$8335 (keyword #f "invoke")) (_o$8336 (keyword #f "fn")) (_o$8337 f) (_o$8338 (keyword #f "args")) (_o$8339 args)) (jolt-hash-map _o$8334 _o$8335 _o$8336 _o$8337 _o$8338 _o$8339)))))) invoke))) + (def-var! "jolt.ir" "invoke" (letrec ((invoke (lambda (f args) (let fnrec8355 ((f f) (args args)) (let* ((_o$8356 (keyword #f "op")) (_o$8357 (keyword #f "invoke")) (_o$8358 (keyword #f "fn")) (_o$8359 f) (_o$8360 (keyword #f "args")) (_o$8361 args)) (jolt-hash-map _o$8356 _o$8357 _o$8358 _o$8359 _o$8360 _o$8361)))))) invoke))) (guard (e (#t #f)) - (def-var! "jolt.ir" "def-node" (letrec ((def-node (case-lambda ((ns name init) (let fnrec8340 ((ns ns) (name name) (init init)) (let* ((_o$8341 (keyword #f "op")) (_o$8342 (keyword #f "def")) (_o$8343 (keyword #f "ns")) (_o$8344 ns) (_o$8345 (keyword #f "name")) (_o$8346 name) (_o$8347 (keyword #f "init")) (_o$8348 init)) (jolt-hash-map _o$8341 _o$8342 _o$8343 _o$8344 _o$8345 _o$8346 _o$8347 _o$8348)))) ((ns name init meta) (let fnrec8349 ((ns ns) (name name) (init init) (meta meta)) (if (jolt-truthy? meta) (let* ((_o$8350 (keyword #f "op")) (_o$8351 (keyword #f "def")) (_o$8352 (keyword #f "ns")) (_o$8353 ns) (_o$8354 (keyword #f "name")) (_o$8355 name) (_o$8356 (keyword #f "init")) (_o$8357 init) (_o$8358 (keyword #f "meta")) (_o$8359 meta)) (jolt-hash-map _o$8350 _o$8351 _o$8352 _o$8353 _o$8354 _o$8355 _o$8356 _o$8357 _o$8358 _o$8359)) (let* ((_o$8360 (keyword #f "op")) (_o$8361 (keyword #f "def")) (_o$8362 (keyword #f "ns")) (_o$8363 ns) (_o$8364 (keyword #f "name")) (_o$8365 name) (_o$8366 (keyword #f "init")) (_o$8367 init)) (jolt-hash-map _o$8360 _o$8361 _o$8362 _o$8363 _o$8364 _o$8365 _o$8366 _o$8367)))))))) def-node))) + (def-var! "jolt.ir" "def-node" (letrec ((def-node (case-lambda ((ns name init) (let fnrec8362 ((ns ns) (name name) (init init)) (let* ((_o$8363 (keyword #f "op")) (_o$8364 (keyword #f "def")) (_o$8365 (keyword #f "ns")) (_o$8366 ns) (_o$8367 (keyword #f "name")) (_o$8368 name) (_o$8369 (keyword #f "init")) (_o$8370 init)) (jolt-hash-map _o$8363 _o$8364 _o$8365 _o$8366 _o$8367 _o$8368 _o$8369 _o$8370)))) ((ns name init meta) (let fnrec8371 ((ns ns) (name name) (init init) (meta meta)) (if (jolt-truthy? meta) (let* ((_o$8372 (keyword #f "op")) (_o$8373 (keyword #f "def")) (_o$8374 (keyword #f "ns")) (_o$8375 ns) (_o$8376 (keyword #f "name")) (_o$8377 name) (_o$8378 (keyword #f "init")) (_o$8379 init) (_o$8380 (keyword #f "meta")) (_o$8381 meta)) (jolt-hash-map _o$8372 _o$8373 _o$8374 _o$8375 _o$8376 _o$8377 _o$8378 _o$8379 _o$8380 _o$8381)) (let* ((_o$8382 (keyword #f "op")) (_o$8383 (keyword #f "def")) (_o$8384 (keyword #f "ns")) (_o$8385 ns) (_o$8386 (keyword #f "name")) (_o$8387 name) (_o$8388 (keyword #f "init")) (_o$8389 init)) (jolt-hash-map _o$8382 _o$8383 _o$8384 _o$8385 _o$8386 _o$8387 _o$8388 _o$8389)))))))) def-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "let-node" (letrec ((let-node (lambda (bindings body) (let fnrec8368 ((bindings bindings) (body body)) (let* ((_o$8369 (keyword #f "op")) (_o$8370 (keyword #f "let")) (_o$8371 (keyword #f "bindings")) (_o$8372 bindings) (_o$8373 (keyword #f "body")) (_o$8374 body)) (jolt-hash-map _o$8369 _o$8370 _o$8371 _o$8372 _o$8373 _o$8374)))))) let-node))) + (def-var! "jolt.ir" "let-node" (letrec ((let-node (lambda (bindings body) (let fnrec8390 ((bindings bindings) (body body)) (let* ((_o$8391 (keyword #f "op")) (_o$8392 (keyword #f "let")) (_o$8393 (keyword #f "bindings")) (_o$8394 bindings) (_o$8395 (keyword #f "body")) (_o$8396 body)) (jolt-hash-map _o$8391 _o$8392 _o$8393 _o$8394 _o$8395 _o$8396)))))) let-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "fn-node" (letrec ((fn-node (lambda (name arities) (let fnrec8375 ((name name) (arities arities)) (if (jolt-truthy? name) (let* ((_o$8376 (keyword #f "op")) (_o$8377 (keyword #f "fn")) (_o$8378 (keyword #f "name")) (_o$8379 name) (_o$8380 (keyword #f "arities")) (_o$8381 arities)) (jolt-hash-map _o$8376 _o$8377 _o$8378 _o$8379 _o$8380 _o$8381)) (let* ((_o$8382 (keyword #f "op")) (_o$8383 (keyword #f "fn")) (_o$8384 (keyword #f "arities")) (_o$8385 arities)) (jolt-hash-map _o$8382 _o$8383 _o$8384 _o$8385))))))) fn-node))) + (def-var! "jolt.ir" "fn-node" (letrec ((fn-node (lambda (name arities) (let fnrec8397 ((name name) (arities arities)) (if (jolt-truthy? name) (let* ((_o$8398 (keyword #f "op")) (_o$8399 (keyword #f "fn")) (_o$8400 (keyword #f "name")) (_o$8401 name) (_o$8402 (keyword #f "arities")) (_o$8403 arities)) (jolt-hash-map _o$8398 _o$8399 _o$8400 _o$8401 _o$8402 _o$8403)) (let* ((_o$8404 (keyword #f "op")) (_o$8405 (keyword #f "fn")) (_o$8406 (keyword #f "arities")) (_o$8407 arities)) (jolt-hash-map _o$8404 _o$8405 _o$8406 _o$8407))))))) fn-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "vector-node" (letrec ((vector-node (lambda (items) (let fnrec8386 ((items items)) (let* ((_o$8387 (keyword #f "op")) (_o$8388 (keyword #f "vector")) (_o$8389 (keyword #f "items")) (_o$8390 items)) (jolt-hash-map _o$8387 _o$8388 _o$8389 _o$8390)))))) vector-node))) + (def-var! "jolt.ir" "vector-node" (letrec ((vector-node (lambda (items) (let fnrec8408 ((items items)) (let* ((_o$8409 (keyword #f "op")) (_o$8410 (keyword #f "vector")) (_o$8411 (keyword #f "items")) (_o$8412 items)) (jolt-hash-map _o$8409 _o$8410 _o$8411 _o$8412)))))) vector-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "map-node" (letrec ((map-node (lambda (pairs) (let fnrec8391 ((pairs pairs)) (let* ((_o$8392 (keyword #f "op")) (_o$8393 (keyword #f "map")) (_o$8394 (keyword #f "pairs")) (_o$8395 pairs)) (jolt-hash-map _o$8392 _o$8393 _o$8394 _o$8395)))))) map-node))) + (def-var! "jolt.ir" "map-node" (letrec ((map-node (lambda (pairs) (let fnrec8413 ((pairs pairs)) (let* ((_o$8414 (keyword #f "op")) (_o$8415 (keyword #f "map")) (_o$8416 (keyword #f "pairs")) (_o$8417 pairs)) (jolt-hash-map _o$8414 _o$8415 _o$8416 _o$8417)))))) map-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "set-node" (letrec ((set-node (lambda (items) (let fnrec8396 ((items items)) (let* ((_o$8397 (keyword #f "op")) (_o$8398 (keyword #f "set")) (_o$8399 (keyword #f "items")) (_o$8400 items)) (jolt-hash-map _o$8397 _o$8398 _o$8399 _o$8400)))))) set-node))) + (def-var! "jolt.ir" "set-node" (letrec ((set-node (lambda (items) (let fnrec8418 ((items items)) (let* ((_o$8419 (keyword #f "op")) (_o$8420 (keyword #f "set")) (_o$8421 (keyword #f "items")) (_o$8422 items)) (jolt-hash-map _o$8419 _o$8420 _o$8421 _o$8422)))))) set-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "quote-node" (letrec ((quote-node (lambda (form) (let fnrec8401 ((form form)) (let* ((_o$8402 (keyword #f "op")) (_o$8403 (keyword #f "quote")) (_o$8404 (keyword #f "form")) (_o$8405 form)) (jolt-hash-map _o$8402 _o$8403 _o$8404 _o$8405)))))) quote-node))) + (def-var! "jolt.ir" "quote-node" (letrec ((quote-node (lambda (form) (let fnrec8423 ((form form)) (let* ((_o$8424 (keyword #f "op")) (_o$8425 (keyword #f "quote")) (_o$8426 (keyword #f "form")) (_o$8427 form)) (jolt-hash-map _o$8424 _o$8425 _o$8426 _o$8427)))))) quote-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "throw-node" (letrec ((throw-node (lambda (expr) (let fnrec8406 ((expr expr)) (let* ((_o$8407 (keyword #f "op")) (_o$8408 (keyword #f "throw")) (_o$8409 (keyword #f "expr")) (_o$8410 expr)) (jolt-hash-map _o$8407 _o$8408 _o$8409 _o$8410)))))) throw-node))) + (def-var! "jolt.ir" "throw-node" (letrec ((throw-node (lambda (expr) (let fnrec8428 ((expr expr)) (let* ((_o$8429 (keyword #f "op")) (_o$8430 (keyword #f "throw")) (_o$8431 (keyword #f "expr")) (_o$8432 expr)) (jolt-hash-map _o$8429 _o$8430 _o$8431 _o$8432)))))) throw-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "coerce-node" (letrec ((coerce-node (lambda (kind expr) (let fnrec8411 ((kind kind) (expr expr)) (let* ((_o$8412 (keyword #f "op")) (_o$8413 (keyword #f "coerce")) (_o$8414 (keyword #f "kind")) (_o$8415 kind) (_o$8416 (keyword #f "expr")) (_o$8417 expr)) (jolt-hash-map _o$8412 _o$8413 _o$8414 _o$8415 _o$8416 _o$8417)))))) coerce-node))) + (def-var! "jolt.ir" "coerce-node" (letrec ((coerce-node (lambda (kind expr) (let fnrec8433 ((kind kind) (expr expr)) (let* ((_o$8434 (keyword #f "op")) (_o$8435 (keyword #f "coerce")) (_o$8436 (keyword #f "kind")) (_o$8437 kind) (_o$8438 (keyword #f "expr")) (_o$8439 expr)) (jolt-hash-map _o$8434 _o$8435 _o$8436 _o$8437 _o$8438 _o$8439)))))) coerce-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "map-ir-children" (letrec ((map-ir-children (lambda (f node) (let fnrec8418 ((f f) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$8419 node) (_a$8420 (keyword #f "test")) (_a$8421 (jolt-invoke f (jolt-get node (keyword #f "test")))) (_a$8422 (keyword #f "then")) (_a$8423 (jolt-invoke f (jolt-get node (keyword #f "then")))) (_a$8424 (keyword #f "else")) (_a$8425 (jolt-invoke f (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$8419 _a$8420 _a$8421 _a$8422 _a$8423 _a$8424 _a$8425)) (if (jolt= op (keyword #f "do")) (let* ((_a$8426 node) (_a$8427 (keyword #f "statements")) (_a$8428 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "statements")))) (_a$8429 (keyword #f "ret")) (_a$8430 (jolt-invoke f (jolt-get node (keyword #f "ret"))))) (jolt-assoc _a$8426 _a$8427 _a$8428 _a$8429 _a$8430)) (if (jolt= op (keyword #f "throw")) (jolt-assoc node (keyword #f "expr") (jolt-invoke f (jolt-get node (keyword #f "expr")))) (if (jolt= op (keyword #f "coerce")) (jolt-assoc node (keyword #f "expr") (jolt-invoke f (jolt-get node (keyword #f "expr")))) (if (jolt= op (keyword #f "set-var")) (jolt-assoc node (keyword #f "val") (jolt-invoke f (jolt-get node (keyword #f "val")))) (if (jolt= op (keyword #f "set-field")) (let* ((_a$8431 node) (_a$8432 (keyword #f "obj")) (_a$8433 (jolt-invoke f (jolt-get node (keyword #f "obj")))) (_a$8434 (keyword #f "val")) (_a$8435 (jolt-invoke f (jolt-get node (keyword #f "val"))))) (jolt-assoc _a$8431 _a$8432 _a$8433 _a$8434 _a$8435)) (if (jolt= op (keyword #f "defmacro")) (jolt-assoc node (keyword #f "fn") (jolt-invoke f (jolt-get node (keyword #f "fn")))) (if (jolt= op (keyword #f "ffi-callable")) (jolt-assoc node (keyword #f "fn") (jolt-invoke f (jolt-get node (keyword #f "fn")))) (if (jolt= op (keyword #f "invoke")) (let* ((_a$8436 node) (_a$8437 (keyword #f "fn")) (_a$8438 (jolt-invoke f (jolt-get node (keyword #f "fn")))) (_a$8439 (keyword #f "args")) (_a$8440 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$8436 _a$8437 _a$8438 _a$8439 _a$8440)) (if (jolt= op (keyword #f "vector")) (jolt-assoc node (keyword #f "items") (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "items")))) (if (jolt= op (keyword #f "set")) (jolt-assoc node (keyword #f "items") (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "items")))) (if (jolt= op (keyword #f "map")) (jolt-assoc node (keyword #f "pairs") (let* ((_a$8444 (var-deref "clojure.core" "mapv")) (_a$8445 (lambda (pr) (let fnrec8441 ((pr pr)) (let* ((_o$8442 (jolt-invoke f (jolt-nth pr 0))) (_o$8443 (jolt-invoke f (jolt-nth pr 1)))) (jolt-vector _o$8442 _o$8443))))) (_a$8446 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$8444 _a$8445 _a$8446))) (if (jolt= op (keyword #f "let")) (let* ((_a$8453 node) (_a$8454 (keyword #f "bindings")) (_a$8455 (let* ((_a$8450 (var-deref "clojure.core" "mapv")) (_a$8451 (lambda (b) (let fnrec8447 ((b b)) (let* ((_o$8448 (jolt-nth b 0)) (_o$8449 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$8448 _o$8449))))) (_a$8452 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$8450 _a$8451 _a$8452))) (_a$8456 (keyword #f "body")) (_a$8457 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$8453 _a$8454 _a$8455 _a$8456 _a$8457)) (if (jolt= op (keyword #f "loop")) (let* ((_a$8464 node) (_a$8465 (keyword #f "bindings")) (_a$8466 (let* ((_a$8461 (var-deref "clojure.core" "mapv")) (_a$8462 (lambda (b) (let fnrec8458 ((b b)) (let* ((_o$8459 (jolt-nth b 0)) (_o$8460 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$8459 _o$8460))))) (_a$8463 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$8461 _a$8462 _a$8463))) (_a$8467 (keyword #f "body")) (_a$8468 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$8464 _a$8465 _a$8466 _a$8467 _a$8468)) (if (jolt= op (keyword #f "recur")) (jolt-assoc node (keyword #f "args") (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args")))) (if (jolt= op (keyword #f "fn")) (jolt-assoc node (keyword #f "arities") (let* ((_a$8470 (var-deref "clojure.core" "mapv")) (_a$8471 (lambda (a) (let fnrec8469 ((a a)) (jolt-assoc a (keyword #f "body") (jolt-invoke f (jolt-get a (keyword #f "body"))))))) (_a$8472 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$8470 _a$8471 _a$8472))) (if (jolt= op (keyword #f "def")) (let* ((n (jolt-assoc node (keyword #f "init") (jolt-invoke f (jolt-get node (keyword #f "init")))))) (if (jolt-truthy? (jolt-get node (keyword #f "meta-expr"))) (jolt-assoc n (keyword #f "meta-expr") (jolt-invoke f (jolt-get node (keyword #f "meta-expr")))) n)) (if (jolt= op (keyword #f "host-call")) (let* ((_a$8473 node) (_a$8474 (keyword #f "target")) (_a$8475 (jolt-invoke f (jolt-get node (keyword #f "target")))) (_a$8476 (keyword #f "args")) (_a$8477 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$8473 _a$8474 _a$8475 _a$8476 _a$8477)) (if (jolt= op (keyword #f "host-new")) (jolt-assoc node (keyword #f "args") (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args")))) (if (jolt= op (keyword #f "try")) (let* ((n (jolt-assoc node (keyword #f "body") (jolt-invoke f (jolt-get node (keyword #f "body"))))) (n (if (jolt-truthy? (jolt-get node (keyword #f "catch-body"))) (jolt-assoc n (keyword #f "catch-body") (jolt-invoke f (jolt-get node (keyword #f "catch-body")))) n)) (n (if (jolt-truthy? (jolt-get node (keyword #f "finally"))) (jolt-assoc n (keyword #f "finally") (jolt-invoke f (jolt-get node (keyword #f "finally")))) n))) n) (if (jolt-truthy? (keyword #f "else")) node jolt-nil)))))))))))))))))))))))))) map-ir-children))) + (def-var! "jolt.ir" "map-ir-children" (letrec ((map-ir-children (lambda (f node) (let fnrec8440 ((f f) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$8441 node) (_a$8442 (keyword #f "test")) (_a$8443 (jolt-invoke f (jolt-get node (keyword #f "test")))) (_a$8444 (keyword #f "then")) (_a$8445 (jolt-invoke f (jolt-get node (keyword #f "then")))) (_a$8446 (keyword #f "else")) (_a$8447 (jolt-invoke f (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$8441 _a$8442 _a$8443 _a$8444 _a$8445 _a$8446 _a$8447)) (if (jolt= op (keyword #f "do")) (let* ((_a$8448 node) (_a$8449 (keyword #f "statements")) (_a$8450 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "statements")))) (_a$8451 (keyword #f "ret")) (_a$8452 (jolt-invoke f (jolt-get node (keyword #f "ret"))))) (jolt-assoc _a$8448 _a$8449 _a$8450 _a$8451 _a$8452)) (if (jolt= op (keyword #f "throw")) (jolt-assoc node (keyword #f "expr") (jolt-invoke f (jolt-get node (keyword #f "expr")))) (if (jolt= op (keyword #f "coerce")) (jolt-assoc node (keyword #f "expr") (jolt-invoke f (jolt-get node (keyword #f "expr")))) (if (jolt= op (keyword #f "set-var")) (jolt-assoc node (keyword #f "val") (jolt-invoke f (jolt-get node (keyword #f "val")))) (if (jolt= op (keyword #f "set-field")) (let* ((_a$8453 node) (_a$8454 (keyword #f "obj")) (_a$8455 (jolt-invoke f (jolt-get node (keyword #f "obj")))) (_a$8456 (keyword #f "val")) (_a$8457 (jolt-invoke f (jolt-get node (keyword #f "val"))))) (jolt-assoc _a$8453 _a$8454 _a$8455 _a$8456 _a$8457)) (if (jolt= op (keyword #f "defmacro")) (jolt-assoc node (keyword #f "fn") (jolt-invoke f (jolt-get node (keyword #f "fn")))) (if (jolt= op (keyword #f "ffi-callable")) (jolt-assoc node (keyword #f "fn") (jolt-invoke f (jolt-get node (keyword #f "fn")))) (if (jolt= op (keyword #f "invoke")) (let* ((_a$8458 node) (_a$8459 (keyword #f "fn")) (_a$8460 (jolt-invoke f (jolt-get node (keyword #f "fn")))) (_a$8461 (keyword #f "args")) (_a$8462 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$8458 _a$8459 _a$8460 _a$8461 _a$8462)) (if (jolt= op (keyword #f "vector")) (jolt-assoc node (keyword #f "items") (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "items")))) (if (jolt= op (keyword #f "set")) (jolt-assoc node (keyword #f "items") (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "items")))) (if (jolt= op (keyword #f "map")) (jolt-assoc node (keyword #f "pairs") (let* ((_a$8466 (var-deref "clojure.core" "mapv")) (_a$8467 (lambda (pr) (let fnrec8463 ((pr pr)) (let* ((_o$8464 (jolt-invoke f (jolt-nth pr 0))) (_o$8465 (jolt-invoke f (jolt-nth pr 1)))) (jolt-vector _o$8464 _o$8465))))) (_a$8468 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$8466 _a$8467 _a$8468))) (if (jolt= op (keyword #f "let")) (let* ((_a$8475 node) (_a$8476 (keyword #f "bindings")) (_a$8477 (let* ((_a$8472 (var-deref "clojure.core" "mapv")) (_a$8473 (lambda (b) (let fnrec8469 ((b b)) (let* ((_o$8470 (jolt-nth b 0)) (_o$8471 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$8470 _o$8471))))) (_a$8474 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$8472 _a$8473 _a$8474))) (_a$8478 (keyword #f "body")) (_a$8479 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$8475 _a$8476 _a$8477 _a$8478 _a$8479)) (if (jolt= op (keyword #f "loop")) (let* ((_a$8486 node) (_a$8487 (keyword #f "bindings")) (_a$8488 (let* ((_a$8483 (var-deref "clojure.core" "mapv")) (_a$8484 (lambda (b) (let fnrec8480 ((b b)) (let* ((_o$8481 (jolt-nth b 0)) (_o$8482 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$8481 _o$8482))))) (_a$8485 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$8483 _a$8484 _a$8485))) (_a$8489 (keyword #f "body")) (_a$8490 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$8486 _a$8487 _a$8488 _a$8489 _a$8490)) (if (jolt= op (keyword #f "recur")) (jolt-assoc node (keyword #f "args") (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args")))) (if (jolt= op (keyword #f "fn")) (jolt-assoc node (keyword #f "arities") (let* ((_a$8492 (var-deref "clojure.core" "mapv")) (_a$8493 (lambda (a) (let fnrec8491 ((a a)) (jolt-assoc a (keyword #f "body") (jolt-invoke f (jolt-get a (keyword #f "body"))))))) (_a$8494 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$8492 _a$8493 _a$8494))) (if (jolt= op (keyword #f "def")) (let* ((n (jolt-assoc node (keyword #f "init") (jolt-invoke f (jolt-get node (keyword #f "init")))))) (if (jolt-truthy? (jolt-get node (keyword #f "meta-expr"))) (jolt-assoc n (keyword #f "meta-expr") (jolt-invoke f (jolt-get node (keyword #f "meta-expr")))) n)) (if (jolt= op (keyword #f "host-call")) (let* ((_a$8495 node) (_a$8496 (keyword #f "target")) (_a$8497 (jolt-invoke f (jolt-get node (keyword #f "target")))) (_a$8498 (keyword #f "args")) (_a$8499 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$8495 _a$8496 _a$8497 _a$8498 _a$8499)) (if (jolt= op (keyword #f "host-new")) (jolt-assoc node (keyword #f "args") (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args")))) (if (jolt= op (keyword #f "try")) (let* ((n (jolt-assoc node (keyword #f "body") (jolt-invoke f (jolt-get node (keyword #f "body"))))) (n (if (jolt-truthy? (jolt-get node (keyword #f "catch-body"))) (jolt-assoc n (keyword #f "catch-body") (jolt-invoke f (jolt-get node (keyword #f "catch-body")))) n)) (n (if (jolt-truthy? (jolt-get node (keyword #f "finally"))) (jolt-assoc n (keyword #f "finally") (jolt-invoke f (jolt-get node (keyword #f "finally")))) n))) n) (if (jolt-truthy? (keyword #f "else")) node jolt-nil)))))))))))))))))))))))))) map-ir-children))) (guard (e (#t #f)) - (def-var! "jolt.ir" "reduce-ir-children" (letrec ((reduce-ir-children (lambda (f acc node) (let fnrec8478 ((f f) (acc acc) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$8482 f) (_a$8483 (let* ((_a$8479 f) (_a$8480 (jolt-invoke f acc (jolt-get node (keyword #f "test")))) (_a$8481 (jolt-get node (keyword #f "then")))) (jolt-invoke _a$8479 _a$8480 _a$8481))) (_a$8484 (jolt-get node (keyword #f "else")))) (jolt-invoke _a$8482 _a$8483 _a$8484)) (if (jolt= op (keyword #f "do")) (let* ((_a$8485 f) (_a$8486 (jolt-reduce f acc (jolt-get node (keyword #f "statements")))) (_a$8487 (jolt-get node (keyword #f "ret")))) (jolt-invoke _a$8485 _a$8486 _a$8487)) (if (jolt= op (keyword #f "throw")) (jolt-invoke f acc (jolt-get node (keyword #f "expr"))) (if (jolt= op (keyword #f "coerce")) (jolt-invoke f acc (jolt-get node (keyword #f "expr"))) (if (jolt= op (keyword #f "set-var")) (jolt-invoke f acc (jolt-get node (keyword #f "val"))) (if (jolt= op (keyword #f "set-field")) (let* ((_a$8488 f) (_a$8489 (jolt-invoke f acc (jolt-get node (keyword #f "obj")))) (_a$8490 (jolt-get node (keyword #f "val")))) (jolt-invoke _a$8488 _a$8489 _a$8490)) (if (jolt= op (keyword #f "defmacro")) (jolt-invoke f acc (jolt-get node (keyword #f "fn"))) (if (jolt= op (keyword #f "ffi-callable")) (jolt-invoke f acc (jolt-get node (keyword #f "fn"))) (if (jolt= op (keyword #f "invoke")) (let* ((_a$8491 f) (_a$8492 (jolt-invoke f acc (jolt-get node (keyword #f "fn")))) (_a$8493 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$8491 _a$8492 _a$8493)) (if (jolt= op (keyword #f "vector")) (jolt-reduce f acc (jolt-get node (keyword #f "items"))) (if (jolt= op (keyword #f "set")) (jolt-reduce f acc (jolt-get node (keyword #f "items"))) (if (jolt= op (keyword #f "map")) (let* ((_a$8498 (lambda (a pr) (let fnrec8494 ((a a) (pr pr)) (let* ((_a$8495 f) (_a$8496 (jolt-invoke f a (jolt-nth pr 0))) (_a$8497 (jolt-nth pr 1))) (jolt-invoke _a$8495 _a$8496 _a$8497))))) (_a$8499 acc) (_a$8500 (jolt-get node (keyword #f "pairs")))) (jolt-reduce _a$8498 _a$8499 _a$8500)) (if (jolt= op (keyword #f "let")) (let* ((_a$8505 f) (_a$8506 (let* ((_a$8502 (lambda (a b) (let fnrec8501 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$8503 acc) (_a$8504 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$8502 _a$8503 _a$8504))) (_a$8507 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$8505 _a$8506 _a$8507)) (if (jolt= op (keyword #f "loop")) (let* ((_a$8512 f) (_a$8513 (let* ((_a$8509 (lambda (a b) (let fnrec8508 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$8510 acc) (_a$8511 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$8509 _a$8510 _a$8511))) (_a$8514 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$8512 _a$8513 _a$8514)) (if (jolt= op (keyword #f "recur")) (jolt-reduce f acc (jolt-get node (keyword #f "args"))) (if (jolt= op (keyword #f "fn")) (let* ((_a$8516 (lambda (a ar) (let fnrec8515 ((a a) (ar ar)) (jolt-invoke f a (jolt-get ar (keyword #f "body")))))) (_a$8517 acc) (_a$8518 (jolt-get node (keyword #f "arities")))) (jolt-reduce _a$8516 _a$8517 _a$8518)) (if (jolt= op (keyword #f "def")) (let* ((a (if (jolt-truthy? (jolt-get node (keyword #f "init"))) (jolt-invoke f acc (jolt-get node (keyword #f "init"))) acc))) (if (jolt-truthy? (jolt-get node (keyword #f "meta-expr"))) (jolt-invoke f a (jolt-get node (keyword #f "meta-expr"))) a)) (if (jolt= op (keyword #f "host-call")) (let* ((_a$8519 f) (_a$8520 (jolt-invoke f acc (jolt-get node (keyword #f "target")))) (_a$8521 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$8519 _a$8520 _a$8521)) (if (jolt= op (keyword #f "host-new")) (jolt-reduce f acc (jolt-get node (keyword #f "args"))) (if (jolt= op (keyword #f "try")) (let* ((a (jolt-invoke f acc (jolt-get node (keyword #f "body")))) (a (if (jolt-truthy? (jolt-get node (keyword #f "catch-body"))) (jolt-invoke f a (jolt-get node (keyword #f "catch-body"))) a)) (a (if (jolt-truthy? (jolt-get node (keyword #f "finally"))) (jolt-invoke f a (jolt-get node (keyword #f "finally"))) a))) a) (if (jolt-truthy? (keyword #f "else")) acc jolt-nil)))))))))))))))))))))))))) reduce-ir-children))) + (def-var! "jolt.ir" "reduce-ir-children" (letrec ((reduce-ir-children (lambda (f acc node) (let fnrec8500 ((f f) (acc acc) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$8504 f) (_a$8505 (let* ((_a$8501 f) (_a$8502 (jolt-invoke f acc (jolt-get node (keyword #f "test")))) (_a$8503 (jolt-get node (keyword #f "then")))) (jolt-invoke _a$8501 _a$8502 _a$8503))) (_a$8506 (jolt-get node (keyword #f "else")))) (jolt-invoke _a$8504 _a$8505 _a$8506)) (if (jolt= op (keyword #f "do")) (let* ((_a$8507 f) (_a$8508 (jolt-reduce f acc (jolt-get node (keyword #f "statements")))) (_a$8509 (jolt-get node (keyword #f "ret")))) (jolt-invoke _a$8507 _a$8508 _a$8509)) (if (jolt= op (keyword #f "throw")) (jolt-invoke f acc (jolt-get node (keyword #f "expr"))) (if (jolt= op (keyword #f "coerce")) (jolt-invoke f acc (jolt-get node (keyword #f "expr"))) (if (jolt= op (keyword #f "set-var")) (jolt-invoke f acc (jolt-get node (keyword #f "val"))) (if (jolt= op (keyword #f "set-field")) (let* ((_a$8510 f) (_a$8511 (jolt-invoke f acc (jolt-get node (keyword #f "obj")))) (_a$8512 (jolt-get node (keyword #f "val")))) (jolt-invoke _a$8510 _a$8511 _a$8512)) (if (jolt= op (keyword #f "defmacro")) (jolt-invoke f acc (jolt-get node (keyword #f "fn"))) (if (jolt= op (keyword #f "ffi-callable")) (jolt-invoke f acc (jolt-get node (keyword #f "fn"))) (if (jolt= op (keyword #f "invoke")) (let* ((_a$8513 f) (_a$8514 (jolt-invoke f acc (jolt-get node (keyword #f "fn")))) (_a$8515 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$8513 _a$8514 _a$8515)) (if (jolt= op (keyword #f "vector")) (jolt-reduce f acc (jolt-get node (keyword #f "items"))) (if (jolt= op (keyword #f "set")) (jolt-reduce f acc (jolt-get node (keyword #f "items"))) (if (jolt= op (keyword #f "map")) (let* ((_a$8520 (lambda (a pr) (let fnrec8516 ((a a) (pr pr)) (let* ((_a$8517 f) (_a$8518 (jolt-invoke f a (jolt-nth pr 0))) (_a$8519 (jolt-nth pr 1))) (jolt-invoke _a$8517 _a$8518 _a$8519))))) (_a$8521 acc) (_a$8522 (jolt-get node (keyword #f "pairs")))) (jolt-reduce _a$8520 _a$8521 _a$8522)) (if (jolt= op (keyword #f "let")) (let* ((_a$8527 f) (_a$8528 (let* ((_a$8524 (lambda (a b) (let fnrec8523 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$8525 acc) (_a$8526 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$8524 _a$8525 _a$8526))) (_a$8529 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$8527 _a$8528 _a$8529)) (if (jolt= op (keyword #f "loop")) (let* ((_a$8534 f) (_a$8535 (let* ((_a$8531 (lambda (a b) (let fnrec8530 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$8532 acc) (_a$8533 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$8531 _a$8532 _a$8533))) (_a$8536 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$8534 _a$8535 _a$8536)) (if (jolt= op (keyword #f "recur")) (jolt-reduce f acc (jolt-get node (keyword #f "args"))) (if (jolt= op (keyword #f "fn")) (let* ((_a$8538 (lambda (a ar) (let fnrec8537 ((a a) (ar ar)) (jolt-invoke f a (jolt-get ar (keyword #f "body")))))) (_a$8539 acc) (_a$8540 (jolt-get node (keyword #f "arities")))) (jolt-reduce _a$8538 _a$8539 _a$8540)) (if (jolt= op (keyword #f "def")) (let* ((a (if (jolt-truthy? (jolt-get node (keyword #f "init"))) (jolt-invoke f acc (jolt-get node (keyword #f "init"))) acc))) (if (jolt-truthy? (jolt-get node (keyword #f "meta-expr"))) (jolt-invoke f a (jolt-get node (keyword #f "meta-expr"))) a)) (if (jolt= op (keyword #f "host-call")) (let* ((_a$8541 f) (_a$8542 (jolt-invoke f acc (jolt-get node (keyword #f "target")))) (_a$8543 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$8541 _a$8542 _a$8543)) (if (jolt= op (keyword #f "host-new")) (jolt-reduce f acc (jolt-get node (keyword #f "args"))) (if (jolt= op (keyword #f "try")) (let* ((a (jolt-invoke f acc (jolt-get node (keyword #f "body")))) (a (if (jolt-truthy? (jolt-get node (keyword #f "catch-body"))) (jolt-invoke f a (jolt-get node (keyword #f "catch-body"))) a)) (a (if (jolt-truthy? (jolt-get node (keyword #f "finally"))) (jolt-invoke f a (jolt-get node (keyword #f "finally"))) a))) a) (if (jolt-truthy? (keyword #f "else")) acc jolt-nil)))))))))))))))))))))))))) reduce-ir-children))) (guard (e (#t #f)) (declare-var! "jolt.analyzer" "analyze")) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "handled" (let* ((_o$8522 "quote") (_o$8523 "if") (_o$8524 "do") (_o$8525 "def") (_o$8526 "fn*") (_o$8527 "let*") (_o$8528 "loop*") (_o$8529 "recur") (_o$8530 "throw") (_o$8531 "try") (_o$8532 "syntax-quote") (_o$8533 "var") (_o$8534 "letfn*") (_o$8535 "set!") (_o$8536 "defmacro")) (jolt-hash-set _o$8522 _o$8523 _o$8524 _o$8525 _o$8526 _o$8527 _o$8528 _o$8529 _o$8530 _o$8531 _o$8532 _o$8533 _o$8534 _o$8535 _o$8536)) (let* ((_o$8537 (keyword #f "private")) (_o$8538 #t)) (jolt-hash-map _o$8537 _o$8538)))) + (def-var-with-meta! "jolt.analyzer" "handled" (let* ((_o$8544 "quote") (_o$8545 "if") (_o$8546 "do") (_o$8547 "def") (_o$8548 "fn*") (_o$8549 "let*") (_o$8550 "loop*") (_o$8551 "recur") (_o$8552 "throw") (_o$8553 "try") (_o$8554 "syntax-quote") (_o$8555 "var") (_o$8556 "letfn*") (_o$8557 "set!") (_o$8558 "defmacro")) (jolt-hash-set _o$8544 _o$8545 _o$8546 _o$8547 _o$8548 _o$8549 _o$8550 _o$8551 _o$8552 _o$8553 _o$8554 _o$8555 _o$8556 _o$8557 _o$8558)) (let* ((_o$8559 (keyword #f "private")) (_o$8560 #t)) (jolt-hash-map _o$8559 _o$8560)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "uncompilable" (letrec ((uncompilable (lambda (why) (let fnrec8539 ((why why)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt/uncompilable: " why)))))) uncompilable) (let* ((_o$8540 (keyword #f "private")) (_o$8541 #t)) (jolt-hash-map _o$8540 _o$8541)))) + (def-var-with-meta! "jolt.analyzer" "uncompilable" (letrec ((uncompilable (lambda (why) (let fnrec8561 ((why why)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt/uncompilable: " why)))))) uncompilable) (let* ((_o$8562 (keyword #f "private")) (_o$8563 #t)) (jolt-hash-map _o$8562 _o$8563)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "gensym-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$8542 (keyword #f "private")) (_o$8543 #t)) (jolt-hash-map _o$8542 _o$8543)))) + (def-var-with-meta! "jolt.analyzer" "gensym-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$8564 (keyword #f "private")) (_o$8565 #t)) (jolt-hash-map _o$8564 _o$8565)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "gen-name" (letrec ((gen-name (lambda (prefix) (let fnrec8544 ((prefix prefix)) (let* ((n (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.analyzer" "gensym-counter")))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.analyzer" "gensym-counter") jolt-inc) (jolt-invoke (var-deref "clojure.core" "str") "_r$" prefix n))))))) gen-name) (let* ((_o$8545 (keyword #f "private")) (_o$8546 #t)) (jolt-hash-map _o$8545 _o$8546)))) + (def-var-with-meta! "jolt.analyzer" "gen-name" (letrec ((gen-name (lambda (prefix) (let fnrec8566 ((prefix prefix)) (let* ((n (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.analyzer" "gensym-counter")))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.analyzer" "gensym-counter") jolt-inc) (jolt-invoke (var-deref "clojure.core" "str") "_r$" prefix n))))))) gen-name) (let* ((_o$8567 (keyword #f "private")) (_o$8568 #t)) (jolt-hash-map _o$8567 _o$8568)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "empty-env" (letrec ((empty-env (lambda () (let fnrec8547 () (let* ((_o$8548 (keyword #f "locals")) (_o$8549 (jolt-hash-set)) (_o$8550 (keyword #f "hints")) (_o$8551 (jolt-hash-map))) (jolt-hash-map _o$8548 _o$8549 _o$8550 _o$8551)))))) empty-env) (let* ((_o$8552 (keyword #f "private")) (_o$8553 #t)) (jolt-hash-map _o$8552 _o$8553)))) + (def-var-with-meta! "jolt.analyzer" "empty-env" (letrec ((empty-env (lambda () (let fnrec8569 () (let* ((_o$8570 (keyword #f "locals")) (_o$8571 (jolt-hash-set)) (_o$8572 (keyword #f "hints")) (_o$8573 (jolt-hash-map))) (jolt-hash-map _o$8570 _o$8571 _o$8572 _o$8573)))))) empty-env) (let* ((_o$8574 (keyword #f "private")) (_o$8575 #t)) (jolt-hash-map _o$8574 _o$8575)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "local?" (letrec ((local? (lambda (env nm) (let fnrec8554 ((env env) (nm nm)) (jolt-contains? (jolt-get env (keyword #f "locals")) nm))))) local?) (let* ((_o$8555 (keyword #f "private")) (_o$8556 #t)) (jolt-hash-map _o$8555 _o$8556)))) + (def-var-with-meta! "jolt.analyzer" "local?" (letrec ((local? (lambda (env nm) (let fnrec8576 ((env env) (nm nm)) (jolt-contains? (jolt-get env (keyword #f "locals")) nm))))) local?) (let* ((_o$8577 (keyword #f "private")) (_o$8578 #t)) (jolt-hash-map _o$8577 _o$8578)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "add-locals" (letrec ((add-locals (lambda (env names) (let fnrec8557 ((env env) (names names)) (jolt-invoke (var-deref "clojure.core" "update") env (keyword #f "locals") (lambda (p__97_) (let fnrec8558 ((p__97_ p__97_)) (jolt-reduce jolt-conj p__97_ names)))))))) add-locals) (let* ((_o$8559 (keyword #f "private")) (_o$8560 #t)) (jolt-hash-map _o$8559 _o$8560)))) + (def-var-with-meta! "jolt.analyzer" "add-locals" (letrec ((add-locals (lambda (env names) (let fnrec8579 ((env env) (names names)) (jolt-invoke (var-deref "clojure.core" "update") env (keyword #f "locals") (lambda (p__97_) (let fnrec8580 ((p__97_ p__97_)) (jolt-reduce jolt-conj p__97_ names)))))))) add-locals) (let* ((_o$8581 (keyword #f "private")) (_o$8582 #t)) (jolt-hash-map _o$8581 _o$8582)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "amp-env-map" (letrec ((amp-env-map (lambda (env) (let fnrec8561 ((env env)) (let* ((_a$8563 (lambda (m n) (let fnrec8562 ((m m) (n n)) (jolt-assoc m (jolt-invoke (var-deref "clojure.core" "symbol") n) jolt-nil)))) (_a$8564 (jolt-hash-map)) (_a$8565 (jolt-get env (keyword #f "locals")))) (jolt-reduce _a$8563 _a$8564 _a$8565)))))) amp-env-map) (let* ((_o$8566 (keyword #f "private")) (_o$8567 #t)) (jolt-hash-map _o$8566 _o$8567)))) + (def-var-with-meta! "jolt.analyzer" "amp-env-map" (letrec ((amp-env-map (lambda (env) (let fnrec8583 ((env env)) (let* ((_a$8585 (lambda (m n) (let fnrec8584 ((m m) (n n)) (jolt-assoc m (jolt-invoke (var-deref "clojure.core" "symbol") n) jolt-nil)))) (_a$8586 (jolt-hash-map)) (_a$8587 (jolt-get env (keyword #f "locals")))) (jolt-reduce _a$8585 _a$8586 _a$8587)))))) amp-env-map) (let* ((_o$8588 (keyword #f "private")) (_o$8589 #t)) (jolt-hash-map _o$8588 _o$8589)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "with-recur" (letrec ((with-recur (lambda (env name) (let fnrec8568 ((env env) (name name)) (jolt-assoc env (keyword #f "recur") name))))) with-recur) (let* ((_o$8569 (keyword #f "private")) (_o$8570 #t)) (jolt-hash-map _o$8569 _o$8570)))) + (def-var-with-meta! "jolt.analyzer" "with-recur" (letrec ((with-recur (lambda (env name) (let fnrec8590 ((env env) (name name)) (jolt-assoc env (keyword #f "recur") name))))) with-recur) (let* ((_o$8591 (keyword #f "private")) (_o$8592 #t)) (jolt-hash-map _o$8591 _o$8592)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "hint-of" (letrec ((hint-of (lambda (ctx sym) (let fnrec8571 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-nil? m) jolt-nil (if (jolt-truthy? (jolt-get m (keyword #f "struct"))) (keyword #f "struct") (if (jolt-truthy? (keyword #f "else")) (let* ((t (jolt-get m (keyword #f "tag")))) (if (jolt-truthy? (let* ((and__25__auto t)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "record-type?") ctx t) and__25__auto))) (keyword #f "struct") jolt-nil)) jolt-nil)))))))) hint-of) (let* ((_o$8572 (keyword #f "private")) (_o$8573 #t)) (jolt-hash-map _o$8572 _o$8573)))) + (def-var-with-meta! "jolt.analyzer" "hint-of" (letrec ((hint-of (lambda (ctx sym) (let fnrec8593 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-nil? m) jolt-nil (if (jolt-truthy? (jolt-get m (keyword #f "struct"))) (keyword #f "struct") (if (jolt-truthy? (keyword #f "else")) (let* ((t (jolt-get m (keyword #f "tag")))) (if (jolt-truthy? (let* ((and__25__auto t)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "record-type?") ctx t) and__25__auto))) (keyword #f "struct") jolt-nil)) jolt-nil)))))))) hint-of) (let* ((_o$8594 (keyword #f "private")) (_o$8595 #t)) (jolt-hash-map _o$8594 _o$8595)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "add-hint" (letrec ((add-hint (lambda (env nm h) (let fnrec8574 ((env env) (nm nm) (h h)) (if (jolt-truthy? h) (jolt-assoc env (keyword #f "hints") (jolt-assoc (jolt-get env (keyword #f "hints")) nm h)) env))))) add-hint) (let* ((_o$8575 (keyword #f "private")) (_o$8576 #t)) (jolt-hash-map _o$8575 _o$8576)))) + (def-var-with-meta! "jolt.analyzer" "add-hint" (letrec ((add-hint (lambda (env nm h) (let fnrec8596 ((env env) (nm nm) (h h)) (if (jolt-truthy? h) (jolt-assoc env (keyword #f "hints") (jolt-assoc (jolt-get env (keyword #f "hints")) nm h)) env))))) add-hint) (let* ((_o$8597 (keyword #f "private")) (_o$8598 #t)) (jolt-hash-map _o$8597 _o$8598)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "phint-of" (letrec ((phint-of (lambda (ctx sym) (let fnrec8577 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-truthy? m) (let* ((t (jolt-get m (keyword #f "tag")))) (if (jolt-truthy? t) (jolt-invoke (var-deref "jolt.host" "record-ctor-key") ctx t) jolt-nil)) jolt-nil)))))) phint-of) (let* ((_o$8578 (keyword #f "private")) (_o$8579 #t)) (jolt-hash-map _o$8578 _o$8579)))) + (def-var-with-meta! "jolt.analyzer" "phint-of" (letrec ((phint-of (lambda (ctx sym) (let fnrec8599 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-truthy? m) (let* ((t (jolt-get m (keyword #f "tag")))) (if (jolt-truthy? t) (jolt-invoke (var-deref "jolt.host" "record-ctor-key") ctx t) jolt-nil)) jolt-nil)))))) phint-of) (let* ((_o$8600 (keyword #f "private")) (_o$8601 #t)) (jolt-hash-map _o$8600 _o$8601)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "tag->nkind" (letrec ((tag->nkind (lambda (t) (let fnrec8580 ((t t)) (let* ((s (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") t)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") t) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") t)) t (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))) (if (jolt= s "double") (keyword #f "double") (if (jolt= s "long") (keyword #f "long") (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))))))) tag->nkind) (let* ((_o$8581 (keyword #f "private")) (_o$8582 #t)) (jolt-hash-map _o$8581 _o$8582)))) + (def-var-with-meta! "jolt.analyzer" "tag->nkind" (letrec ((tag->nkind (lambda (t) (let fnrec8602 ((t t)) (let* ((s (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") t)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") t) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") t)) t (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))) (if (jolt= s "double") (keyword #f "double") (if (jolt= s "long") (keyword #f "long") (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))))))) tag->nkind) (let* ((_o$8603 (keyword #f "private")) (_o$8604 #t)) (jolt-hash-map _o$8603 _o$8604)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "nhint-of" (letrec ((nhint-of (lambda (ctx sym) (let fnrec8583 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-truthy? m) (jolt-invoke (var-deref "jolt.analyzer" "tag->nkind") (jolt-get m (keyword #f "tag"))) jolt-nil)))))) nhint-of) (let* ((_o$8584 (keyword #f "private")) (_o$8585 #t)) (jolt-hash-map _o$8584 _o$8585)))) + (def-var-with-meta! "jolt.analyzer" "nhint-of" (letrec ((nhint-of (lambda (ctx sym) (let fnrec8605 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-truthy? m) (jolt-invoke (var-deref "jolt.analyzer" "tag->nkind") (jolt-get m (keyword #f "tag"))) jolt-nil)))))) nhint-of) (let* ((_o$8606 (keyword #f "private")) (_o$8607 #t)) (jolt-hash-map _o$8606 _o$8607)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "with-ret-nhint" (letrec ((with-ret-nhint (lambda (node kind) (let fnrec8586 ((node node) (kind kind)) (if (jolt-truthy? (let* ((and__25__auto kind)) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "fn") (jolt-get node (keyword #f "op"))) and__25__auto))) (jolt-assoc node (keyword #f "arities") (let* ((_a$8588 (var-deref "clojure.core" "mapv")) (_a$8589 (lambda (a) (let fnrec8587 ((a a)) (if (jolt-truthy? (jolt-get a (keyword #f "ret-nhint"))) a (jolt-assoc a (keyword #f "ret-nhint") kind))))) (_a$8590 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$8588 _a$8589 _a$8590))) node))))) with-ret-nhint) (let* ((_o$8591 (keyword #f "private")) (_o$8592 #t)) (jolt-hash-map _o$8591 _o$8592)))) + (def-var-with-meta! "jolt.analyzer" "with-ret-nhint" (letrec ((with-ret-nhint (lambda (node kind) (let fnrec8608 ((node node) (kind kind)) (if (jolt-truthy? (let* ((and__25__auto kind)) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "fn") (jolt-get node (keyword #f "op"))) and__25__auto))) (jolt-assoc node (keyword #f "arities") (let* ((_a$8610 (var-deref "clojure.core" "mapv")) (_a$8611 (lambda (a) (let fnrec8609 ((a a)) (if (jolt-truthy? (jolt-get a (keyword #f "ret-nhint"))) a (jolt-assoc a (keyword #f "ret-nhint") kind))))) (_a$8612 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$8610 _a$8611 _a$8612))) node))))) with-ret-nhint) (let* ((_o$8613 (keyword #f "private")) (_o$8614 #t)) (jolt-hash-map _o$8613 _o$8614)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-seq" (letrec ((analyze-seq (lambda (ctx forms env) (let fnrec8593 ((ctx ctx) (forms forms) (env env)) (let* ((v (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__98_) (let fnrec8594 ((p__98_ p__98_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__98_ env))) forms)) (n (jolt-count v))) (if (jolt-zero? n) (jolt-invoke (var-deref "jolt.ir" "const") jolt-nil) (if (jolt= 1 n) (jolt-first v) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$8595 (var-deref "jolt.ir" "do-node")) (_a$8596 (jolt-invoke (var-deref "clojure.core" "subvec") v 0 (jolt-dec n))) (_a$8597 (jolt-peek v))) (jolt-invoke _a$8595 _a$8596 _a$8597)) jolt-nil)))))))) analyze-seq) (let* ((_o$8598 (keyword #f "private")) (_o$8599 #t)) (jolt-hash-map _o$8598 _o$8599)))) + (def-var-with-meta! "jolt.analyzer" "analyze-seq" (letrec ((analyze-seq (lambda (ctx forms env) (let fnrec8615 ((ctx ctx) (forms forms) (env env)) (let* ((v (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__98_) (let fnrec8616 ((p__98_ p__98_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__98_ env))) forms)) (n (jolt-count v))) (if (jolt-zero? n) (jolt-invoke (var-deref "jolt.ir" "const") jolt-nil) (if (jolt= 1 n) (jolt-first v) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$8617 (var-deref "jolt.ir" "do-node")) (_a$8618 (jolt-invoke (var-deref "clojure.core" "subvec") v 0 (jolt-dec n))) (_a$8619 (jolt-peek v))) (jolt-invoke _a$8617 _a$8618 _a$8619)) jolt-nil)))))))) analyze-seq) (let* ((_o$8620 (keyword #f "private")) (_o$8621 #t)) (jolt-hash-map _o$8620 _o$8621)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-bindings" (letrec ((analyze-bindings (lambda (ctx bvec env) (let fnrec8600 ((ctx ctx) (bvec bvec) (env env)) (let* ((i 0) (env env) (pairs (jolt-vector))) (let loop8601 ((i i) (env env) (pairs pairs)) (if (< i (jolt-count bvec)) (let* ((bsym (jolt-nth bvec i))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") bsym)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "destructuring binding") jolt-nil) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") bsym)) (init (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth bvec (jolt-inc i)) env))) (let* ((_a$8608 (+ i 2)) (_a$8609 (let* ((_a$8602 (var-deref "jolt.analyzer" "add-hint")) (_a$8603 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector nm))) (_a$8604 nm) (_a$8605 (jolt-invoke (var-deref "jolt.analyzer" "hint-of") ctx bsym))) (jolt-invoke _a$8602 _a$8603 _a$8604 _a$8605))) (_a$8610 (jolt-conj pairs (let* ((_o$8606 nm) (_o$8607 init)) (jolt-vector _o$8606 _o$8607))))) (loop8601 _a$8608 _a$8609 _a$8610))))) (let* ((_o$8611 pairs) (_o$8612 env)) (jolt-vector _o$8611 _o$8612))))))))) analyze-bindings) (let* ((_o$8613 (keyword #f "private")) (_o$8614 #t)) (jolt-hash-map _o$8613 _o$8614)))) + (def-var-with-meta! "jolt.analyzer" "analyze-bindings" (letrec ((analyze-bindings (lambda (ctx bvec env) (let fnrec8622 ((ctx ctx) (bvec bvec) (env env)) (let* ((i 0) (env env) (pairs (jolt-vector))) (let loop8623 ((i i) (env env) (pairs pairs)) (if (< i (jolt-count bvec)) (let* ((bsym (jolt-nth bvec i))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") bsym)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "destructuring binding") jolt-nil) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") bsym)) (init (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth bvec (jolt-inc i)) env))) (let* ((_a$8630 (+ i 2)) (_a$8631 (let* ((_a$8624 (var-deref "jolt.analyzer" "add-hint")) (_a$8625 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector nm))) (_a$8626 nm) (_a$8627 (jolt-invoke (var-deref "jolt.analyzer" "hint-of") ctx bsym))) (jolt-invoke _a$8624 _a$8625 _a$8626 _a$8627))) (_a$8632 (jolt-conj pairs (let* ((_o$8628 nm) (_o$8629 init)) (jolt-vector _o$8628 _o$8629))))) (loop8623 _a$8630 _a$8631 _a$8632))))) (let* ((_o$8633 pairs) (_o$8634 env)) (jolt-vector _o$8633 _o$8634))))))))) analyze-bindings) (let* ((_o$8635 (keyword #f "private")) (_o$8636 #t)) (jolt-hash-map _o$8635 _o$8636)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "parse-params" (letrec ((parse-params (lambda (ctx pvec) (let fnrec8615 ((ctx ctx) (pvec pvec)) (let* ((i 0) (fixed (jolt-vector)) (rest-name jolt-nil) (hints (jolt-vector)) (phints (jolt-vector)) (nhints (jolt-vector))) (let loop8616 ((i i) (fixed fixed) (rest-name rest-name) (hints hints) (phints phints) (nhints nhints)) (if (< i (jolt-count pvec)) (let* ((p (jolt-nth pvec i))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") p)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "destructuring fn param") jolt-nil) (if (jolt= "&" (jolt-invoke (var-deref "jolt.host" "form-sym-name") p)) (let* ((r (jolt-nth pvec (jolt-inc i)))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") r)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "destructuring fn rest") jolt-nil) (let* ((_a$8617 (+ i 2)) (_a$8618 fixed) (_a$8619 (jolt-invoke (var-deref "jolt.host" "form-sym-name") r)) (_a$8620 hints) (_a$8621 phints) (_a$8622 nhints)) (loop8616 _a$8617 _a$8618 _a$8619 _a$8620 _a$8621 _a$8622)))) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") p)) (h (jolt-invoke (var-deref "jolt.analyzer" "hint-of") ctx p)) (ph (jolt-invoke (var-deref "jolt.analyzer" "phint-of") ctx p)) (nh (jolt-invoke (var-deref "jolt.analyzer" "nhint-of") ctx p))) (let* ((_a$8629 (jolt-inc i)) (_a$8630 (jolt-conj fixed nm)) (_a$8631 rest-name) (_a$8632 (if (jolt-truthy? h) (jolt-conj hints (let* ((_o$8623 nm) (_o$8624 h)) (jolt-vector _o$8623 _o$8624))) hints)) (_a$8633 (if (jolt-truthy? ph) (jolt-conj phints (let* ((_o$8625 nm) (_o$8626 ph)) (jolt-vector _o$8625 _o$8626))) phints)) (_a$8634 (if (jolt-truthy? nh) (jolt-conj nhints (let* ((_o$8627 nm) (_o$8628 nh)) (jolt-vector _o$8627 _o$8628))) nhints))) (loop8616 _a$8629 _a$8630 _a$8631 _a$8632 _a$8633 _a$8634)))))) (let* ((_o$8635 (keyword #f "fixed")) (_o$8636 fixed) (_o$8637 (keyword #f "rest")) (_o$8638 rest-name) (_o$8639 (keyword #f "hints")) (_o$8640 hints) (_o$8641 (keyword #f "phints")) (_o$8642 phints) (_o$8643 (keyword #f "nhints")) (_o$8644 nhints)) (jolt-hash-map _o$8635 _o$8636 _o$8637 _o$8638 _o$8639 _o$8640 _o$8641 _o$8642 _o$8643 _o$8644))))))))) parse-params) (let* ((_o$8645 (keyword #f "private")) (_o$8646 #t)) (jolt-hash-map _o$8645 _o$8646)))) + (def-var-with-meta! "jolt.analyzer" "parse-params" (letrec ((parse-params (lambda (ctx pvec) (let fnrec8637 ((ctx ctx) (pvec pvec)) (let* ((i 0) (fixed (jolt-vector)) (rest-name jolt-nil) (hints (jolt-vector)) (phints (jolt-vector)) (nhints (jolt-vector))) (let loop8638 ((i i) (fixed fixed) (rest-name rest-name) (hints hints) (phints phints) (nhints nhints)) (if (< i (jolt-count pvec)) (let* ((p (jolt-nth pvec i))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") p)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "destructuring fn param") jolt-nil) (if (jolt= "&" (jolt-invoke (var-deref "jolt.host" "form-sym-name") p)) (let* ((r (jolt-nth pvec (jolt-inc i)))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") r)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "destructuring fn rest") jolt-nil) (let* ((_a$8639 (+ i 2)) (_a$8640 fixed) (_a$8641 (jolt-invoke (var-deref "jolt.host" "form-sym-name") r)) (_a$8642 hints) (_a$8643 phints) (_a$8644 nhints)) (loop8638 _a$8639 _a$8640 _a$8641 _a$8642 _a$8643 _a$8644)))) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") p)) (h (jolt-invoke (var-deref "jolt.analyzer" "hint-of") ctx p)) (ph (jolt-invoke (var-deref "jolt.analyzer" "phint-of") ctx p)) (nh (jolt-invoke (var-deref "jolt.analyzer" "nhint-of") ctx p))) (let* ((_a$8651 (jolt-inc i)) (_a$8652 (jolt-conj fixed nm)) (_a$8653 rest-name) (_a$8654 (if (jolt-truthy? h) (jolt-conj hints (let* ((_o$8645 nm) (_o$8646 h)) (jolt-vector _o$8645 _o$8646))) hints)) (_a$8655 (if (jolt-truthy? ph) (jolt-conj phints (let* ((_o$8647 nm) (_o$8648 ph)) (jolt-vector _o$8647 _o$8648))) phints)) (_a$8656 (if (jolt-truthy? nh) (jolt-conj nhints (let* ((_o$8649 nm) (_o$8650 nh)) (jolt-vector _o$8649 _o$8650))) nhints))) (loop8638 _a$8651 _a$8652 _a$8653 _a$8654 _a$8655 _a$8656)))))) (let* ((_o$8657 (keyword #f "fixed")) (_o$8658 fixed) (_o$8659 (keyword #f "rest")) (_o$8660 rest-name) (_o$8661 (keyword #f "hints")) (_o$8662 hints) (_o$8663 (keyword #f "phints")) (_o$8664 phints) (_o$8665 (keyword #f "nhints")) (_o$8666 nhints)) (jolt-hash-map _o$8657 _o$8658 _o$8659 _o$8660 _o$8661 _o$8662 _o$8663 _o$8664 _o$8665 _o$8666))))))))) parse-params) (let* ((_o$8667 (keyword #f "private")) (_o$8668 #t)) (jolt-hash-map _o$8667 _o$8668)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "uniquify-params" (letrec ((uniquify-params (lambda (names) (let fnrec8647 ((names names)) (let* ((n (jolt-count names))) (let* ((i 0) (out (jolt-vector))) (let loop8648 ((i i) (out out)) (if (< i n) (let* ((nm (jolt-nth names i)) (dup? (let* ((j (jolt-inc i))) (let loop8649 ((j j)) (if (>= j n) #f (if (jolt= nm (jolt-nth names j)) #t (if (jolt-truthy? (keyword #f "else")) (loop8649 (jolt-inc j)) jolt-nil))))))) (let* ((_a$8650 (jolt-inc i)) (_a$8651 (jolt-conj out (if (jolt-truthy? dup?) (jolt-invoke (var-deref "jolt.analyzer" "gen-name") (jolt-invoke (var-deref "clojure.core" "str") nm "_")) nm)))) (loop8648 _a$8650 _a$8651))) out)))))))) uniquify-params) (let* ((_o$8652 (keyword #f "private")) (_o$8653 #t)) (jolt-hash-map _o$8652 _o$8653)))) + (def-var-with-meta! "jolt.analyzer" "uniquify-params" (letrec ((uniquify-params (lambda (names) (let fnrec8669 ((names names)) (let* ((n (jolt-count names))) (let* ((i 0) (out (jolt-vector))) (let loop8670 ((i i) (out out)) (if (< i n) (let* ((nm (jolt-nth names i)) (dup? (let* ((j (jolt-inc i))) (let loop8671 ((j j)) (if (>= j n) #f (if (jolt= nm (jolt-nth names j)) #t (if (jolt-truthy? (keyword #f "else")) (loop8671 (jolt-inc j)) jolt-nil))))))) (let* ((_a$8672 (jolt-inc i)) (_a$8673 (jolt-conj out (if (jolt-truthy? dup?) (jolt-invoke (var-deref "jolt.analyzer" "gen-name") (jolt-invoke (var-deref "clojure.core" "str") nm "_")) nm)))) (loop8670 _a$8672 _a$8673))) out)))))))) uniquify-params) (let* ((_o$8674 (keyword #f "private")) (_o$8675 #t)) (jolt-hash-map _o$8674 _o$8675)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-arity" (letrec ((analyze-arity (lambda (ctx pvec body env fn-name) (let fnrec8654 ((ctx ctx) (pvec pvec) (body body) (env env) (fn-name fn-name)) (let* ((pp (jolt-invoke (var-deref "jolt.analyzer" "parse-params") ctx (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") pvec)))) (fixed (jolt-invoke (var-deref "jolt.analyzer" "uniquify-params") (jolt-get pp (keyword #f "fixed")))) (rst (jolt-get pp (keyword #f "rest"))) (rname (jolt-invoke (var-deref "jolt.analyzer" "gen-name") (let* ((_a$8655 (var-deref "clojure.core" "str")) (_a$8656 (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (_a$8657 "/") (_a$8658 (let* ((or__26__auto fn-name)) (if (jolt-truthy? or__26__auto) or__26__auto "fn"))) (_a$8659 "--")) (jolt-invoke _a$8655 _a$8656 _a$8657 _a$8658 _a$8659)))) (names (let* ((G__148 (jolt-invoke (var-deref "clojure.core" "vec") fixed))) (let* ((G__149 (if (jolt-truthy? rst) (jolt-conj G__148 rst) G__148))) (let* ((G__150 (if (jolt-truthy? fn-name) (jolt-conj G__149 fn-name) G__149))) G__150)))) (env0 (jolt-invoke (var-deref "jolt.analyzer" "with-recur") (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names) rname)) (env* (let* ((_a$8665 (lambda (e pr) (let fnrec8660 ((e e) (pr pr)) (let* ((_a$8661 (var-deref "jolt.analyzer" "add-hint")) (_a$8662 e) (_a$8663 (jolt-nth pr 0)) (_a$8664 (jolt-nth pr 1))) (jolt-invoke _a$8661 _a$8662 _a$8663 _a$8664))))) (_a$8666 env0) (_a$8667 (jolt-get pp (keyword #f "hints")))) (jolt-reduce _a$8665 _a$8666 _a$8667))) (arity (let* ((_o$8668 (keyword #f "params")) (_o$8669 fixed) (_o$8670 (keyword #f "recur-name")) (_o$8671 rname) (_o$8672 (keyword #f "body")) (_o$8673 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx body env*))) (jolt-hash-map _o$8668 _o$8669 _o$8670 _o$8671 _o$8672 _o$8673))) (arity (if (jolt-truthy? (jolt-seq (jolt-get pp (keyword #f "phints")))) (jolt-assoc arity (keyword #f "phints") (jolt-get pp (keyword #f "phints"))) arity)) (arity (if (jolt-truthy? (jolt-seq (jolt-get pp (keyword #f "nhints")))) (jolt-assoc arity (keyword #f "nhints") (jolt-get pp (keyword #f "nhints"))) arity))) (if (jolt-truthy? rst) (jolt-assoc arity (keyword #f "rest") rst) arity)))))) analyze-arity) (let* ((_o$8674 (keyword #f "private")) (_o$8675 #t)) (jolt-hash-map _o$8674 _o$8675)))) + (def-var-with-meta! "jolt.analyzer" "analyze-arity" (letrec ((analyze-arity (lambda (ctx pvec body env fn-name) (let fnrec8676 ((ctx ctx) (pvec pvec) (body body) (env env) (fn-name fn-name)) (let* ((pp (jolt-invoke (var-deref "jolt.analyzer" "parse-params") ctx (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") pvec)))) (fixed (jolt-invoke (var-deref "jolt.analyzer" "uniquify-params") (jolt-get pp (keyword #f "fixed")))) (rst (jolt-get pp (keyword #f "rest"))) (rname (jolt-invoke (var-deref "jolt.analyzer" "gen-name") (let* ((_a$8677 (var-deref "clojure.core" "str")) (_a$8678 (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (_a$8679 "/") (_a$8680 (let* ((or__26__auto fn-name)) (if (jolt-truthy? or__26__auto) or__26__auto "fn"))) (_a$8681 "--")) (jolt-invoke _a$8677 _a$8678 _a$8679 _a$8680 _a$8681)))) (names (let* ((G__148 (jolt-invoke (var-deref "clojure.core" "vec") fixed))) (let* ((G__149 (if (jolt-truthy? rst) (jolt-conj G__148 rst) G__148))) (let* ((G__150 (if (jolt-truthy? fn-name) (jolt-conj G__149 fn-name) G__149))) G__150)))) (env0 (jolt-invoke (var-deref "jolt.analyzer" "with-recur") (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names) rname)) (env* (let* ((_a$8687 (lambda (e pr) (let fnrec8682 ((e e) (pr pr)) (let* ((_a$8683 (var-deref "jolt.analyzer" "add-hint")) (_a$8684 e) (_a$8685 (jolt-nth pr 0)) (_a$8686 (jolt-nth pr 1))) (jolt-invoke _a$8683 _a$8684 _a$8685 _a$8686))))) (_a$8688 env0) (_a$8689 (jolt-get pp (keyword #f "hints")))) (jolt-reduce _a$8687 _a$8688 _a$8689))) (arity (let* ((_o$8690 (keyword #f "params")) (_o$8691 fixed) (_o$8692 (keyword #f "recur-name")) (_o$8693 rname) (_o$8694 (keyword #f "body")) (_o$8695 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx body env*))) (jolt-hash-map _o$8690 _o$8691 _o$8692 _o$8693 _o$8694 _o$8695))) (arity (if (jolt-truthy? (jolt-seq (jolt-get pp (keyword #f "phints")))) (jolt-assoc arity (keyword #f "phints") (jolt-get pp (keyword #f "phints"))) arity)) (arity (if (jolt-truthy? (jolt-seq (jolt-get pp (keyword #f "nhints")))) (jolt-assoc arity (keyword #f "nhints") (jolt-get pp (keyword #f "nhints"))) arity))) (if (jolt-truthy? rst) (jolt-assoc arity (keyword #f "rest") rst) arity)))))) analyze-arity) (let* ((_o$8696 (keyword #f "private")) (_o$8697 #t)) (jolt-hash-map _o$8696 _o$8697)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "strip-arglist-meta" (letrec ((strip-arglist-meta (lambda (form) (let fnrec8676 ((form form)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") form)) (let* ((es (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") form)))) (if (jolt-truthy? (let* ((and__25__auto (jolt= 3 (jolt-count es)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-first es)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "with-meta" (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first es))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-vec?") (jolt-nth es 1)) and__25__auto)) and__25__auto)) and__25__auto))) (jolt-nth es 1) form)) form))))) strip-arglist-meta) (let* ((_o$8677 (keyword #f "private")) (_o$8678 #t)) (jolt-hash-map _o$8677 _o$8678)))) + (def-var-with-meta! "jolt.analyzer" "strip-arglist-meta" (letrec ((strip-arglist-meta (lambda (form) (let fnrec8698 ((form form)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") form)) (let* ((es (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") form)))) (if (jolt-truthy? (let* ((and__25__auto (jolt= 3 (jolt-count es)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-first es)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "with-meta" (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first es))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-vec?") (jolt-nth es 1)) and__25__auto)) and__25__auto)) and__25__auto))) (jolt-nth es 1) form)) form))))) strip-arglist-meta) (let* ((_o$8699 (keyword #f "private")) (_o$8700 #t)) (jolt-hash-map _o$8699 _o$8700)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-fn" (letrec ((analyze-fn (lambda (ctx items env) (let fnrec8679 ((ctx ctx) (items items) (env env)) (let* ((named (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth items 1))) (fn-name (if (jolt-truthy? named) (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth items 1)) jolt-nil)) (rest-items (if (jolt-truthy? named) (jolt-drop 2 items) (jolt-drop 1 items))) (first* (jolt-invoke (var-deref "jolt.analyzer" "strip-arglist-meta") (jolt-first rest-items)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-vec?") first*)) (jolt-invoke (var-deref "jolt.ir" "fn-node") fn-name (jolt-vector (jolt-invoke (var-deref "jolt.analyzer" "analyze-arity") ctx first* (jolt-rest rest-items) env fn-name))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") first*)) (jolt-invoke (var-deref "jolt.ir" "fn-node") fn-name (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (clause) (let fnrec8680 ((clause clause)) (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") clause)))) (let* ((_a$8681 (var-deref "jolt.analyzer" "analyze-arity")) (_a$8682 ctx) (_a$8683 (jolt-invoke (var-deref "jolt.analyzer" "strip-arglist-meta") (jolt-first cl))) (_a$8684 (jolt-rest cl)) (_a$8685 env) (_a$8686 fn-name)) (jolt-invoke _a$8681 _a$8682 _a$8683 _a$8684 _a$8685 _a$8686))))) rest-items)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "fn: bad params") jolt-nil)))))))) analyze-fn) (let* ((_o$8687 (keyword #f "private")) (_o$8688 #t)) (jolt-hash-map _o$8687 _o$8688)))) + (def-var-with-meta! "jolt.analyzer" "analyze-fn" (letrec ((analyze-fn (lambda (ctx items env) (let fnrec8701 ((ctx ctx) (items items) (env env)) (let* ((named (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth items 1))) (fn-name (if (jolt-truthy? named) (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth items 1)) jolt-nil)) (rest-items (if (jolt-truthy? named) (jolt-drop 2 items) (jolt-drop 1 items))) (first* (jolt-invoke (var-deref "jolt.analyzer" "strip-arglist-meta") (jolt-first rest-items)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-vec?") first*)) (jolt-invoke (var-deref "jolt.ir" "fn-node") fn-name (jolt-vector (jolt-invoke (var-deref "jolt.analyzer" "analyze-arity") ctx first* (jolt-rest rest-items) env fn-name))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") first*)) (jolt-invoke (var-deref "jolt.ir" "fn-node") fn-name (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (clause) (let fnrec8702 ((clause clause)) (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") clause)))) (let* ((_a$8703 (var-deref "jolt.analyzer" "analyze-arity")) (_a$8704 ctx) (_a$8705 (jolt-invoke (var-deref "jolt.analyzer" "strip-arglist-meta") (jolt-first cl))) (_a$8706 (jolt-rest cl)) (_a$8707 env) (_a$8708 fn-name)) (jolt-invoke _a$8703 _a$8704 _a$8705 _a$8706 _a$8707 _a$8708))))) rest-items)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "fn: bad params") jolt-nil)))))))) analyze-fn) (let* ((_o$8709 (keyword #f "private")) (_o$8710 #t)) (jolt-hash-map _o$8709 _o$8710)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "catch-all-names" (let* ((_o$8689 "Throwable") (_o$8690 "java.lang.Throwable") (_o$8691 "Object") (_o$8692 "java.lang.Object")) (jolt-hash-set _o$8689 _o$8690 _o$8691 _o$8692)) (let* ((_o$8693 (keyword #f "private")) (_o$8694 #t)) (jolt-hash-map _o$8693 _o$8694)))) + (def-var-with-meta! "jolt.analyzer" "catch-all-names" (let* ((_o$8711 "Throwable") (_o$8712 "java.lang.Throwable") (_o$8713 "Object") (_o$8714 "java.lang.Object")) (jolt-hash-set _o$8711 _o$8712 _o$8713 _o$8714)) (let* ((_o$8715 (keyword #f "private")) (_o$8716 #t)) (jolt-hash-map _o$8715 _o$8716)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-try" (letrec ((analyze-try (lambda (ctx items env) (let fnrec8695 ((ctx ctx) (items items) (env env)) (let* ((clauses (jolt-rest items)) (body (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))) (catches (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))) (finally-body (jolt-invoke (var-deref "clojure.core" "atom") jolt-nil))) (begin (begin (jolt-count (jolt-map (lambda (c) (let fnrec8696 ((c c)) (begin (let* ((head (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") c)) (jolt-first (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") c))) jolt-nil)) (hname (if (jolt-truthy? (let* ((and__25__auto head)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") head) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") head) jolt-nil))) (if (jolt= hname "catch") (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") c)))) (begin (if (let* ((or__26__auto (< (jolt-count cl) 3))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth cl 2))))) (jolt-throw "Unable to parse catch clause; expected (catch class binding body*)") jolt-nil) (jolt-invoke (var-deref "clojure.core" "swap!") catches jolt-conj cl))) (if (jolt= hname "finally") (jolt-invoke (var-deref "clojure.core" "reset!") finally-body (jolt-rest (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") c)))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "swap!") body jolt-conj c) jolt-nil)))) jolt-nil))) clauses)) jolt-nil) (let* ((n (let* ((_o$8697 (keyword #f "op")) (_o$8698 (keyword #f "try")) (_o$8699 (keyword #f "body")) (_o$8700 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-invoke (var-deref "clojure.core" "deref") body) env))) (jolt-hash-map _o$8697 _o$8698 _o$8699 _o$8700))) (n (if (jolt-truthy? (jolt-seq (jolt-invoke (var-deref "clojure.core" "deref") catches))) (let* ((evar-name (jolt-invoke (var-deref "jolt.analyzer" "gen-name") "catch")) (evar (jolt-invoke (var-deref "clojure.core" "symbol") evar-name)) (dispatch (let* ((_a$8705 (lambda (_else cl) (let fnrec8701 ((_else _else) (cl cl)) (let* ((cform (jolt-nth cl 1)) (bindsym (jolt-nth cl 2)) (bodyf (jolt-drop 3 cl)) (letform (jolt-cons (jolt-symbol #f "let") (jolt-cons (jolt-vector bindsym evar) bodyf))) (fullname (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") cform)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") cform) jolt-nil)) (catch-all? (let* ((or__26__auto (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") cform)))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-contains? (var-deref "jolt.analyzer" "catch-all-names") fullname))))) (if (jolt-truthy? catch-all?) letform (jolt-list (jolt-symbol #f "if") (let* ((_a$8702 (jolt-symbol #f "or")) (_a$8703 (jolt-list (jolt-symbol #f "instance?") cform evar)) (_a$8704 (jolt-list (jolt-symbol #f "__catch-broad?") fullname evar))) (jolt-list _a$8702 _a$8703 _a$8704)) letform _else)))))) (_a$8706 (jolt-list (jolt-symbol #f "throw") evar)) (_a$8707 (jolt-reverse (jolt-invoke (var-deref "clojure.core" "deref") catches)))) (jolt-reduce _a$8705 _a$8706 _a$8707)))) (jolt-assoc n (keyword #f "catch-sym") evar-name (keyword #f "catch-body") (let* ((_a$8708 (var-deref "jolt.analyzer" "analyze-seq")) (_a$8709 ctx) (_a$8710 (jolt-list dispatch)) (_a$8711 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector evar-name)))) (jolt-invoke _a$8708 _a$8709 _a$8710 _a$8711)))) n)) (n (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "deref") finally-body)) (jolt-assoc n (keyword #f "finally") (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-invoke (var-deref "clojure.core" "deref") finally-body) env)) n))) n))))))) analyze-try) (let* ((_o$8712 (keyword #f "private")) (_o$8713 #t)) (jolt-hash-map _o$8712 _o$8713)))) + (def-var-with-meta! "jolt.analyzer" "analyze-try" (letrec ((analyze-try (lambda (ctx items env) (let fnrec8717 ((ctx ctx) (items items) (env env)) (let* ((clauses (jolt-rest items)) (body (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))) (catches (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))) (finally-body (jolt-invoke (var-deref "clojure.core" "atom") jolt-nil))) (begin (begin (jolt-count (jolt-map (lambda (c) (let fnrec8718 ((c c)) (begin (let* ((head (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") c)) (jolt-first (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") c))) jolt-nil)) (hname (if (jolt-truthy? (let* ((and__25__auto head)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") head) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") head) jolt-nil))) (if (jolt= hname "catch") (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") c)))) (begin (if (let* ((or__26__auto (< (jolt-count cl) 3))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth cl 2))))) (jolt-throw "Unable to parse catch clause; expected (catch class binding body*)") jolt-nil) (jolt-invoke (var-deref "clojure.core" "swap!") catches jolt-conj cl))) (if (jolt= hname "finally") (jolt-invoke (var-deref "clojure.core" "reset!") finally-body (jolt-rest (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") c)))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "swap!") body jolt-conj c) jolt-nil)))) jolt-nil))) clauses)) jolt-nil) (let* ((n (let* ((_o$8719 (keyword #f "op")) (_o$8720 (keyword #f "try")) (_o$8721 (keyword #f "body")) (_o$8722 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-invoke (var-deref "clojure.core" "deref") body) env))) (jolt-hash-map _o$8719 _o$8720 _o$8721 _o$8722))) (n (if (jolt-truthy? (jolt-seq (jolt-invoke (var-deref "clojure.core" "deref") catches))) (let* ((evar-name (jolt-invoke (var-deref "jolt.analyzer" "gen-name") "catch")) (evar (jolt-invoke (var-deref "clojure.core" "symbol") evar-name)) (dispatch (let* ((_a$8727 (lambda (_else cl) (let fnrec8723 ((_else _else) (cl cl)) (let* ((cform (jolt-nth cl 1)) (bindsym (jolt-nth cl 2)) (bodyf (jolt-drop 3 cl)) (letform (jolt-cons (jolt-symbol #f "let") (jolt-cons (jolt-vector bindsym evar) bodyf))) (fullname (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") cform)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") cform) jolt-nil)) (catch-all? (let* ((or__26__auto (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") cform)))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-contains? (var-deref "jolt.analyzer" "catch-all-names") fullname))))) (if (jolt-truthy? catch-all?) letform (jolt-list (jolt-symbol #f "if") (let* ((_a$8724 (jolt-symbol #f "or")) (_a$8725 (jolt-list (jolt-symbol #f "instance?") cform evar)) (_a$8726 (jolt-list (jolt-symbol #f "__catch-broad?") fullname evar))) (jolt-list _a$8724 _a$8725 _a$8726)) letform _else)))))) (_a$8728 (jolt-list (jolt-symbol #f "throw") evar)) (_a$8729 (jolt-reverse (jolt-invoke (var-deref "clojure.core" "deref") catches)))) (jolt-reduce _a$8727 _a$8728 _a$8729)))) (jolt-assoc n (keyword #f "catch-sym") evar-name (keyword #f "catch-body") (let* ((_a$8730 (var-deref "jolt.analyzer" "analyze-seq")) (_a$8731 ctx) (_a$8732 (jolt-list dispatch)) (_a$8733 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector evar-name)))) (jolt-invoke _a$8730 _a$8731 _a$8732 _a$8733)))) n)) (n (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "deref") finally-body)) (jolt-assoc n (keyword #f "finally") (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-invoke (var-deref "clojure.core" "deref") finally-body) env)) n))) n))))))) analyze-try) (let* ((_o$8734 (keyword #f "private")) (_o$8735 #t)) (jolt-hash-map _o$8734 _o$8735)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-letfn*" (letrec ((analyze-letfn* (lambda (ctx items env) (let fnrec8714 ((ctx ctx) (items items) (env env)) (let* ((bvec (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 1)))) (n (quotient (jolt-count bvec) 2)) (names (let* ((_a$8716 (var-deref "clojure.core" "mapv")) (_a$8717 (lambda (i) (let fnrec8715 ((i i)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth bvec (* 2 i)))))) (_a$8718 (jolt-range n))) (jolt-invoke _a$8716 _a$8717 _a$8718))) (env* (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names)) (binds (let* ((_a$8722 (var-deref "clojure.core" "mapv")) (_a$8723 (lambda (i) (let fnrec8719 ((i i)) (let* ((_o$8720 (jolt-nth names i)) (_o$8721 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth bvec (jolt-inc (* 2 i))) env*))) (jolt-vector _o$8720 _o$8721))))) (_a$8724 (jolt-range n))) (jolt-invoke _a$8722 _a$8723 _a$8724)))) (let* ((_o$8725 (keyword #f "op")) (_o$8726 (keyword #f "let")) (_o$8727 (keyword #f "letrec")) (_o$8728 #t) (_o$8729 (keyword #f "bindings")) (_o$8730 binds) (_o$8731 (keyword #f "body")) (_o$8732 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env*))) (jolt-hash-map _o$8725 _o$8726 _o$8727 _o$8728 _o$8729 _o$8730 _o$8731 _o$8732))))))) analyze-letfn*) (let* ((_o$8733 (keyword #f "private")) (_o$8734 #t)) (jolt-hash-map _o$8733 _o$8734)))) + (def-var-with-meta! "jolt.analyzer" "analyze-letfn*" (letrec ((analyze-letfn* (lambda (ctx items env) (let fnrec8736 ((ctx ctx) (items items) (env env)) (let* ((bvec (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 1)))) (n (quotient (jolt-count bvec) 2)) (names (let* ((_a$8738 (var-deref "clojure.core" "mapv")) (_a$8739 (lambda (i) (let fnrec8737 ((i i)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth bvec (* 2 i)))))) (_a$8740 (jolt-range n))) (jolt-invoke _a$8738 _a$8739 _a$8740))) (env* (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names)) (binds (let* ((_a$8744 (var-deref "clojure.core" "mapv")) (_a$8745 (lambda (i) (let fnrec8741 ((i i)) (let* ((_o$8742 (jolt-nth names i)) (_o$8743 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth bvec (jolt-inc (* 2 i))) env*))) (jolt-vector _o$8742 _o$8743))))) (_a$8746 (jolt-range n))) (jolt-invoke _a$8744 _a$8745 _a$8746)))) (let* ((_o$8747 (keyword #f "op")) (_o$8748 (keyword #f "let")) (_o$8749 (keyword #f "letrec")) (_o$8750 #t) (_o$8751 (keyword #f "bindings")) (_o$8752 binds) (_o$8753 (keyword #f "body")) (_o$8754 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env*))) (jolt-hash-map _o$8747 _o$8748 _o$8749 _o$8750 _o$8751 _o$8752 _o$8753 _o$8754))))))) analyze-letfn*) (let* ((_o$8755 (keyword #f "private")) (_o$8756 #t)) (jolt-hash-map _o$8755 _o$8756)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "field-head?" (letrec ((field-head? (lambda (nm) (let fnrec8735 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 2))) (if (jolt-truthy? and__25__auto) (jolt= ".-" (jolt-invoke (var-deref "clojure.core" "subs") nm 0 2)) and__25__auto)))))) field-head?) (let* ((_o$8736 (keyword #f "private")) (_o$8737 #t)) (jolt-hash-map _o$8736 _o$8737)))) + (def-var-with-meta! "jolt.analyzer" "field-head?" (letrec ((field-head? (lambda (nm) (let fnrec8757 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 2))) (if (jolt-truthy? and__25__auto) (jolt= ".-" (jolt-invoke (var-deref "clojure.core" "subs") nm 0 2)) and__25__auto)))))) field-head?) (let* ((_o$8758 (keyword #f "private")) (_o$8759 #t)) (jolt-hash-map _o$8758 _o$8759)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "def-meta-expr" (letrec ((def-meta-expr (lambda (ctx base env) (let fnrec8738 ((ctx ctx) (base base) (env env)) (if (jolt-pos? (jolt-count base)) (jolt-invoke (var-deref "jolt.ir" "map-node") (let* ((_a$8742 (var-deref "clojure.core" "mapv")) (_a$8743 (lambda (p) (let fnrec8739 ((p p)) (let* ((k (jolt-first p)) (v (jolt-invoke (var-deref "clojure.core" "second") p))) (let* ((_o$8740 (jolt-invoke (var-deref "jolt.ir" "const") k)) (_o$8741 (if (jolt= k (keyword #f "tag")) (jolt-invoke (var-deref "jolt.ir" "quote-node") v) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx v env)))) (jolt-vector _o$8740 _o$8741)))))) (_a$8744 (jolt-seq base))) (jolt-invoke _a$8742 _a$8743 _a$8744))) jolt-nil))))) def-meta-expr) (let* ((_o$8745 (keyword #f "private")) (_o$8746 #t)) (jolt-hash-map _o$8745 _o$8746)))) + (def-var-with-meta! "jolt.analyzer" "def-meta-expr" (letrec ((def-meta-expr (lambda (ctx base env) (let fnrec8760 ((ctx ctx) (base base) (env env)) (if (jolt-pos? (jolt-count base)) (jolt-invoke (var-deref "jolt.ir" "map-node") (let* ((_a$8764 (var-deref "clojure.core" "mapv")) (_a$8765 (lambda (p) (let fnrec8761 ((p p)) (let* ((k (jolt-first p)) (v (jolt-invoke (var-deref "clojure.core" "second") p))) (let* ((_o$8762 (jolt-invoke (var-deref "jolt.ir" "const") k)) (_o$8763 (if (jolt= k (keyword #f "tag")) (jolt-invoke (var-deref "jolt.ir" "quote-node") v) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx v env)))) (jolt-vector _o$8762 _o$8763)))))) (_a$8766 (jolt-seq base))) (jolt-invoke _a$8764 _a$8765 _a$8766))) jolt-nil))))) def-meta-expr) (let* ((_o$8767 (keyword #f "private")) (_o$8768 #t)) (jolt-hash-map _o$8767 _o$8768)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-def" (letrec ((analyze-def (lambda (ctx items env) (let fnrec8747 ((ctx ctx) (items items) (env env)) (let* ((name-sym (jolt-nth items 1))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") name-sym)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "def name with map metadata") jolt-nil) (if (< (jolt-count items) 3) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") name-sym)) (cur (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx))) (begin (jolt-invoke (var-deref "jolt.host" "host-intern!") ctx cur nm) (let* ((_o$8748 (keyword #f "op")) (_o$8749 (keyword #f "def")) (_o$8750 (keyword #f "ns")) (_o$8751 cur) (_o$8752 (keyword #f "name")) (_o$8753 nm) (_o$8754 (keyword #f "no-init")) (_o$8755 #t)) (jolt-hash-map _o$8748 _o$8749 _o$8750 _o$8751 _o$8752 _o$8753 _o$8754 _o$8755)))) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") name-sym)) (cur (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (has-doc (let* ((and__25__auto (> (jolt-count items) 3))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "string?") (jolt-nth items 2)) and__25__auto))) (val-form (jolt-nth items (if (jolt-truthy? has-doc) 3 2))) (base0 (let* ((or__26__auto (jolt-invoke (var-deref "jolt.host" "form-sym-meta") name-sym))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-hash-map)))) (tag (jolt-get base0 (keyword #f "tag"))) (tag-name (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") tag)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") tag) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") tag)) tag (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))) (base-meta (if (jolt-truthy? tag-name) (let* ((c (jolt-invoke (var-deref "jolt.host" "resolve-class-hint") tag-name))) (if (jolt-truthy? c) (jolt-assoc base0 (keyword #f "tag") c) base0)) base0)) (node-meta (if (jolt-truthy? has-doc) (jolt-assoc base-meta (keyword #f "doc") (jolt-nth items 2)) base-meta))) (begin (jolt-invoke (var-deref "jolt.host" "host-intern!") ctx cur nm) (let* ((node (jolt-invoke (var-deref "jolt.ir" "def-node") cur nm (let* ((_a$8756 (var-deref "jolt.analyzer" "with-ret-nhint")) (_a$8757 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx val-form env)) (_a$8758 (jolt-invoke (var-deref "jolt.analyzer" "tag->nkind") tag))) (jolt-invoke _a$8756 _a$8757 _a$8758)) node-meta)) (me (jolt-invoke (var-deref "jolt.analyzer" "def-meta-expr") ctx node-meta env))) (if (jolt-truthy? me) (jolt-assoc node (keyword #f "meta-expr") me) node))))))))))) analyze-def) (let* ((_o$8759 (keyword #f "private")) (_o$8760 #t)) (jolt-hash-map _o$8759 _o$8760)))) + (def-var-with-meta! "jolt.analyzer" "analyze-def" (letrec ((analyze-def (lambda (ctx items env) (let fnrec8769 ((ctx ctx) (items items) (env env)) (let* ((name-sym (jolt-nth items 1))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") name-sym)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "def name with map metadata") jolt-nil) (if (< (jolt-count items) 3) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") name-sym)) (cur (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx))) (begin (jolt-invoke (var-deref "jolt.host" "host-intern!") ctx cur nm) (let* ((_o$8770 (keyword #f "op")) (_o$8771 (keyword #f "def")) (_o$8772 (keyword #f "ns")) (_o$8773 cur) (_o$8774 (keyword #f "name")) (_o$8775 nm) (_o$8776 (keyword #f "no-init")) (_o$8777 #t)) (jolt-hash-map _o$8770 _o$8771 _o$8772 _o$8773 _o$8774 _o$8775 _o$8776 _o$8777)))) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") name-sym)) (cur (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (has-doc (let* ((and__25__auto (> (jolt-count items) 3))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "string?") (jolt-nth items 2)) and__25__auto))) (val-form (jolt-nth items (if (jolt-truthy? has-doc) 3 2))) (base0 (let* ((or__26__auto (jolt-invoke (var-deref "jolt.host" "form-sym-meta") name-sym))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-hash-map)))) (tag (jolt-get base0 (keyword #f "tag"))) (tag-name (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") tag)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") tag) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") tag)) tag (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))) (base-meta (if (jolt-truthy? tag-name) (let* ((c (jolt-invoke (var-deref "jolt.host" "resolve-class-hint") tag-name))) (if (jolt-truthy? c) (jolt-assoc base0 (keyword #f "tag") c) base0)) base0)) (node-meta (if (jolt-truthy? has-doc) (jolt-assoc base-meta (keyword #f "doc") (jolt-nth items 2)) base-meta))) (begin (jolt-invoke (var-deref "jolt.host" "host-intern!") ctx cur nm) (let* ((node (jolt-invoke (var-deref "jolt.ir" "def-node") cur nm (let* ((_a$8778 (var-deref "jolt.analyzer" "with-ret-nhint")) (_a$8779 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx val-form env)) (_a$8780 (jolt-invoke (var-deref "jolt.analyzer" "tag->nkind") tag))) (jolt-invoke _a$8778 _a$8779 _a$8780)) node-meta)) (me (jolt-invoke (var-deref "jolt.analyzer" "def-meta-expr") ctx node-meta env))) (if (jolt-truthy? me) (jolt-assoc node (keyword #f "meta-expr") me) node))))))))))) analyze-def) (let* ((_o$8781 (keyword #f "private")) (_o$8782 #t)) (jolt-hash-map _o$8781 _o$8782)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-set!" (letrec ((analyze-set! (lambda (ctx items env) (let fnrec8761 ((ctx ctx) (items items) (env env)) (let* ((target (jolt-nth items 1)) (val-node (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 2) env)) (ti (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") target)) (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") target)) jolt-nil)) (thead (if (jolt-truthy? (let* ((and__25__auto ti)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-pos? (jolt-count ti)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-first ti)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first ti)) jolt-nil))) (if (jolt-truthy? (let* ((and__25__auto thead)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "field-head?") thead) and__25__auto))) (let* ((_o$8762 (keyword #f "op")) (_o$8763 (keyword #f "set-field")) (_o$8764 (keyword #f "obj")) (_o$8765 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth ti 1) env)) (_o$8766 (keyword #f "field")) (_o$8767 (jolt-invoke (var-deref "clojure.core" "subs") thead 2)) (_o$8768 (keyword #f "val")) (_o$8769 val-node)) (jolt-hash-map _o$8762 _o$8763 _o$8764 _o$8765 _o$8766 _o$8767 _o$8768 _o$8769)) (if (jolt-truthy? (let* ((and__25__auto (jolt= thead "."))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= (jolt-count ti) 3))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth ti 1)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth ti 2)))) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "class") (jolt-get (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx (jolt-nth ti 1)) (keyword #f "kind"))) and__25__auto)) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((_a$8773 (var-deref "jolt.ir" "invoke")) (_a$8774 (jolt-invoke (var-deref "jolt.ir" "var-ref") "jolt.host" "set-static-field!")) (_a$8775 (let* ((_o$8770 (jolt-invoke (var-deref "jolt.ir" "const") (jolt-get (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx (jolt-nth ti 1)) (keyword #f "name")))) (_o$8771 (jolt-invoke (var-deref "jolt.ir" "const") (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth ti 2)))) (_o$8772 val-node)) (jolt-vector _o$8770 _o$8771 _o$8772)))) (jolt-invoke _a$8773 _a$8774 _a$8775)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") target)) (begin (if (jolt-truthy? (jolt-invoke (var-deref "jolt.analyzer" "local?") env (jolt-invoke (var-deref "jolt.host" "form-sym-name") target))) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "set! of a local") jolt-nil) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx target))) (begin (if (jolt-not (jolt= (keyword #f "var") (jolt-get r (keyword #f "kind")))) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "set! of a non-var") jolt-nil) (let* ((_o$8779 (keyword #f "op")) (_o$8780 (keyword #f "set-var")) (_o$8781 (keyword #f "the-var")) (_o$8782 (let* ((_a$8776 (var-deref "jolt.ir" "the-var")) (_a$8777 (jolt-get r (keyword #f "ns"))) (_a$8778 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8776 _a$8777 _a$8778))) (_o$8783 (keyword #f "val")) (_o$8784 val-node)) (jolt-hash-map _o$8779 _o$8780 _o$8781 _o$8782 _o$8783 _o$8784))))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "set! of an unsupported target") jolt-nil))))))))) analyze-set!) (let* ((_o$8785 (keyword #f "private")) (_o$8786 #t)) (jolt-hash-map _o$8785 _o$8786)))) + (def-var-with-meta! "jolt.analyzer" "analyze-set!" (letrec ((analyze-set! (lambda (ctx items env) (let fnrec8783 ((ctx ctx) (items items) (env env)) (let* ((target (jolt-nth items 1)) (val-node (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 2) env)) (ti (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") target)) (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") target)) jolt-nil)) (thead (if (jolt-truthy? (let* ((and__25__auto ti)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-pos? (jolt-count ti)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-first ti)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first ti)) jolt-nil))) (if (jolt-truthy? (let* ((and__25__auto thead)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "field-head?") thead) and__25__auto))) (let* ((_o$8784 (keyword #f "op")) (_o$8785 (keyword #f "set-field")) (_o$8786 (keyword #f "obj")) (_o$8787 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth ti 1) env)) (_o$8788 (keyword #f "field")) (_o$8789 (jolt-invoke (var-deref "clojure.core" "subs") thead 2)) (_o$8790 (keyword #f "val")) (_o$8791 val-node)) (jolt-hash-map _o$8784 _o$8785 _o$8786 _o$8787 _o$8788 _o$8789 _o$8790 _o$8791)) (if (jolt-truthy? (let* ((and__25__auto (jolt= thead "."))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= (jolt-count ti) 3))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth ti 1)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth ti 2)))) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "class") (jolt-get (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx (jolt-nth ti 1)) (keyword #f "kind"))) and__25__auto)) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((_a$8795 (var-deref "jolt.ir" "invoke")) (_a$8796 (jolt-invoke (var-deref "jolt.ir" "var-ref") "jolt.host" "set-static-field!")) (_a$8797 (let* ((_o$8792 (jolt-invoke (var-deref "jolt.ir" "const") (jolt-get (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx (jolt-nth ti 1)) (keyword #f "name")))) (_o$8793 (jolt-invoke (var-deref "jolt.ir" "const") (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth ti 2)))) (_o$8794 val-node)) (jolt-vector _o$8792 _o$8793 _o$8794)))) (jolt-invoke _a$8795 _a$8796 _a$8797)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") target)) (begin (if (jolt-truthy? (jolt-invoke (var-deref "jolt.analyzer" "local?") env (jolt-invoke (var-deref "jolt.host" "form-sym-name") target))) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "set! of a local") jolt-nil) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx target))) (begin (if (jolt-not (jolt= (keyword #f "var") (jolt-get r (keyword #f "kind")))) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "set! of a non-var") jolt-nil) (let* ((_o$8801 (keyword #f "op")) (_o$8802 (keyword #f "set-var")) (_o$8803 (keyword #f "the-var")) (_o$8804 (let* ((_a$8798 (var-deref "jolt.ir" "the-var")) (_a$8799 (jolt-get r (keyword #f "ns"))) (_a$8800 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8798 _a$8799 _a$8800))) (_o$8805 (keyword #f "val")) (_o$8806 val-node)) (jolt-hash-map _o$8801 _o$8802 _o$8803 _o$8804 _o$8805 _o$8806))))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "set! of an unsupported target") jolt-nil))))))))) analyze-set!) (let* ((_o$8807 (keyword #f "private")) (_o$8808 #t)) (jolt-hash-map _o$8807 _o$8808)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-special" (letrec ((analyze-special (lambda (ctx op items env) (let fnrec8787 ((ctx ctx) (op op) (items items) (env env)) (let* ((G__151 op)) (if (jolt= G__151 "quote") (jolt-invoke (var-deref "jolt.ir" "quote-node") (jolt-invoke (var-deref "clojure.core" "second") items)) (if (jolt= G__151 "if") (begin (if (let* ((or__26__auto (< (jolt-count items) 3))) (if (jolt-truthy? or__26__auto) or__26__auto (> (jolt-count items) 4))) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Wrong number of args (" (jolt-dec (jolt-count items)) ") passed to: if")) jolt-nil) (let* ((_a$8788 (var-deref "jolt.ir" "if-node")) (_a$8789 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_a$8790 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 2) env)) (_a$8791 (if (> (jolt-count items) 3) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 3) env) (jolt-invoke (var-deref "jolt.ir" "const") jolt-nil)))) (jolt-invoke _a$8788 _a$8789 _a$8790 _a$8791))) (if (jolt= G__151 "do") (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-rest items) env) (if (jolt= G__151 "throw") (jolt-invoke (var-deref "jolt.ir" "throw-node") (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (if (jolt= G__151 "def") (jolt-invoke (var-deref "jolt.analyzer" "analyze-def") ctx items env) (if (jolt= G__151 "let*") (let* ((bvec (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 1)))) (r (jolt-invoke (var-deref "jolt.analyzer" "analyze-bindings") ctx bvec env))) (let* ((_a$8796 (var-deref "jolt.ir" "let-node")) (_a$8797 (jolt-first r)) (_a$8798 (let* ((_a$8792 (var-deref "jolt.analyzer" "analyze-seq")) (_a$8793 ctx) (_a$8794 (jolt-drop 2 items)) (_a$8795 (jolt-invoke (var-deref "clojure.core" "second") r))) (jolt-invoke _a$8792 _a$8793 _a$8794 _a$8795)))) (jolt-invoke _a$8796 _a$8797 _a$8798))) (if (jolt= G__151 "loop*") (let* ((bvec (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 1)))) (rname (jolt-invoke (var-deref "jolt.analyzer" "gen-name") "loop")) (r (jolt-invoke (var-deref "jolt.analyzer" "analyze-bindings") ctx bvec env)) (env** (jolt-invoke (var-deref "jolt.analyzer" "with-recur") (jolt-invoke (var-deref "clojure.core" "second") r) rname))) (let* ((_o$8799 (keyword #f "op")) (_o$8800 (keyword #f "loop")) (_o$8801 (keyword #f "recur-name")) (_o$8802 rname) (_o$8803 (keyword #f "bindings")) (_o$8804 (jolt-first r)) (_o$8805 (keyword #f "body")) (_o$8806 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env**))) (jolt-hash-map _o$8799 _o$8800 _o$8801 _o$8802 _o$8803 _o$8804 _o$8805 _o$8806))) (if (jolt= G__151 "recur") (let* ((rt (jolt-get env (keyword #f "recur")))) (begin (if (jolt-not rt) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "recur outside loop/fn") jolt-nil) (let* ((_o$8811 (keyword #f "op")) (_o$8812 (keyword #f "recur")) (_o$8813 (keyword #f "recur-name")) (_o$8814 rt) (_o$8815 (keyword #f "args")) (_o$8816 (let* ((_a$8808 (var-deref "clojure.core" "mapv")) (_a$8809 (lambda (p__99_) (let fnrec8807 ((p__99_ p__99_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__99_ env)))) (_a$8810 (jolt-rest items))) (jolt-invoke _a$8808 _a$8809 _a$8810)))) (jolt-hash-map _o$8811 _o$8812 _o$8813 _o$8814 _o$8815 _o$8816)))) (if (jolt= G__151 "try") (jolt-invoke (var-deref "jolt.analyzer" "analyze-try") ctx items env) (if (jolt= G__151 "letfn*") (jolt-invoke (var-deref "jolt.analyzer" "analyze-letfn*") ctx items env) (if (jolt= G__151 "fn*") (jolt-invoke (var-deref "jolt.analyzer" "analyze-fn") ctx items env) (if (jolt= G__151 "syntax-quote") (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-invoke (var-deref "jolt.host" "form-syntax-quote-lower") ctx (jolt-invoke (var-deref "clojure.core" "second") items)) env) (if (jolt= G__151 "var") (let* ((sym (jolt-invoke (var-deref "clojure.core" "second") items)) (r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx sym))) (if (jolt= (keyword #f "var") (jolt-get r (keyword #f "kind"))) (let* ((_a$8817 (var-deref "jolt.ir" "the-var")) (_a$8818 (jolt-get r (keyword #f "ns"))) (_a$8819 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8817 _a$8818 _a$8819)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "var of non-var " (jolt-invoke (var-deref "jolt.host" "form-sym-name") sym))))) (if (jolt= G__151 "defmacro") (let* ((name-sym (jolt-nth items 1)) (nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") name-sym)) (cur (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (after (jolt-drop 2 items)) (after (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") (jolt-first after))) (jolt-rest after) after)) (after (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-map?") (jolt-first after))) (jolt-rest after) after)) (fn-form (jolt-cons (jolt-invoke (var-deref "clojure.core" "symbol") "fn") after))) (begin (jolt-invoke (var-deref "jolt.host" "host-intern!") ctx cur nm) (let* ((_o$8820 (keyword #f "op")) (_o$8821 (keyword #f "defmacro")) (_o$8822 (keyword #f "ns")) (_o$8823 cur) (_o$8824 (keyword #f "name")) (_o$8825 nm) (_o$8826 (keyword #f "fn")) (_o$8827 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx fn-form env))) (jolt-hash-map _o$8820 _o$8821 _o$8822 _o$8823 _o$8824 _o$8825 _o$8826 _o$8827)))) (if (jolt= G__151 "set!") (jolt-invoke (var-deref "jolt.analyzer" "analyze-set!") ctx items env) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "special form " op)))))))))))))))))))))) analyze-special) (let* ((_o$8828 (keyword #f "private")) (_o$8829 #t)) (jolt-hash-map _o$8828 _o$8829)))) + (def-var-with-meta! "jolt.analyzer" "analyze-special" (letrec ((analyze-special (lambda (ctx op items env) (let fnrec8809 ((ctx ctx) (op op) (items items) (env env)) (let* ((G__151 op)) (if (jolt= G__151 "quote") (jolt-invoke (var-deref "jolt.ir" "quote-node") (jolt-invoke (var-deref "clojure.core" "second") items)) (if (jolt= G__151 "if") (begin (if (let* ((or__26__auto (< (jolt-count items) 3))) (if (jolt-truthy? or__26__auto) or__26__auto (> (jolt-count items) 4))) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Wrong number of args (" (jolt-dec (jolt-count items)) ") passed to: if")) jolt-nil) (let* ((_a$8810 (var-deref "jolt.ir" "if-node")) (_a$8811 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_a$8812 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 2) env)) (_a$8813 (if (> (jolt-count items) 3) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 3) env) (jolt-invoke (var-deref "jolt.ir" "const") jolt-nil)))) (jolt-invoke _a$8810 _a$8811 _a$8812 _a$8813))) (if (jolt= G__151 "do") (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-rest items) env) (if (jolt= G__151 "throw") (jolt-invoke (var-deref "jolt.ir" "throw-node") (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (if (jolt= G__151 "def") (jolt-invoke (var-deref "jolt.analyzer" "analyze-def") ctx items env) (if (jolt= G__151 "let*") (let* ((bvec (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 1)))) (r (jolt-invoke (var-deref "jolt.analyzer" "analyze-bindings") ctx bvec env))) (let* ((_a$8818 (var-deref "jolt.ir" "let-node")) (_a$8819 (jolt-first r)) (_a$8820 (let* ((_a$8814 (var-deref "jolt.analyzer" "analyze-seq")) (_a$8815 ctx) (_a$8816 (jolt-drop 2 items)) (_a$8817 (jolt-invoke (var-deref "clojure.core" "second") r))) (jolt-invoke _a$8814 _a$8815 _a$8816 _a$8817)))) (jolt-invoke _a$8818 _a$8819 _a$8820))) (if (jolt= G__151 "loop*") (let* ((bvec (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 1)))) (rname (jolt-invoke (var-deref "jolt.analyzer" "gen-name") "loop")) (r (jolt-invoke (var-deref "jolt.analyzer" "analyze-bindings") ctx bvec env)) (env** (jolt-invoke (var-deref "jolt.analyzer" "with-recur") (jolt-invoke (var-deref "clojure.core" "second") r) rname))) (let* ((_o$8821 (keyword #f "op")) (_o$8822 (keyword #f "loop")) (_o$8823 (keyword #f "recur-name")) (_o$8824 rname) (_o$8825 (keyword #f "bindings")) (_o$8826 (jolt-first r)) (_o$8827 (keyword #f "body")) (_o$8828 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env**))) (jolt-hash-map _o$8821 _o$8822 _o$8823 _o$8824 _o$8825 _o$8826 _o$8827 _o$8828))) (if (jolt= G__151 "recur") (let* ((rt (jolt-get env (keyword #f "recur")))) (begin (if (jolt-not rt) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "recur outside loop/fn") jolt-nil) (let* ((_o$8833 (keyword #f "op")) (_o$8834 (keyword #f "recur")) (_o$8835 (keyword #f "recur-name")) (_o$8836 rt) (_o$8837 (keyword #f "args")) (_o$8838 (let* ((_a$8830 (var-deref "clojure.core" "mapv")) (_a$8831 (lambda (p__99_) (let fnrec8829 ((p__99_ p__99_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__99_ env)))) (_a$8832 (jolt-rest items))) (jolt-invoke _a$8830 _a$8831 _a$8832)))) (jolt-hash-map _o$8833 _o$8834 _o$8835 _o$8836 _o$8837 _o$8838)))) (if (jolt= G__151 "try") (jolt-invoke (var-deref "jolt.analyzer" "analyze-try") ctx items env) (if (jolt= G__151 "letfn*") (jolt-invoke (var-deref "jolt.analyzer" "analyze-letfn*") ctx items env) (if (jolt= G__151 "fn*") (jolt-invoke (var-deref "jolt.analyzer" "analyze-fn") ctx items env) (if (jolt= G__151 "syntax-quote") (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-invoke (var-deref "jolt.host" "form-syntax-quote-lower") ctx (jolt-invoke (var-deref "clojure.core" "second") items)) env) (if (jolt= G__151 "var") (let* ((sym (jolt-invoke (var-deref "clojure.core" "second") items)) (r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx sym))) (if (jolt= (keyword #f "var") (jolt-get r (keyword #f "kind"))) (let* ((_a$8839 (var-deref "jolt.ir" "the-var")) (_a$8840 (jolt-get r (keyword #f "ns"))) (_a$8841 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8839 _a$8840 _a$8841)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "var of non-var " (jolt-invoke (var-deref "jolt.host" "form-sym-name") sym))))) (if (jolt= G__151 "defmacro") (let* ((name-sym (jolt-nth items 1)) (nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") name-sym)) (cur (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (after (jolt-drop 2 items)) (after (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") (jolt-first after))) (jolt-rest after) after)) (after (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-map?") (jolt-first after))) (jolt-rest after) after)) (fn-form (jolt-cons (jolt-invoke (var-deref "clojure.core" "symbol") "fn") after))) (begin (jolt-invoke (var-deref "jolt.host" "host-intern!") ctx cur nm) (let* ((_o$8842 (keyword #f "op")) (_o$8843 (keyword #f "defmacro")) (_o$8844 (keyword #f "ns")) (_o$8845 cur) (_o$8846 (keyword #f "name")) (_o$8847 nm) (_o$8848 (keyword #f "fn")) (_o$8849 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx fn-form env))) (jolt-hash-map _o$8842 _o$8843 _o$8844 _o$8845 _o$8846 _o$8847 _o$8848 _o$8849)))) (if (jolt= G__151 "set!") (jolt-invoke (var-deref "jolt.analyzer" "analyze-set!") ctx items env) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "special form " op)))))))))))))))))))))) analyze-special) (let* ((_o$8850 (keyword #f "private")) (_o$8851 #t)) (jolt-hash-map _o$8850 _o$8851)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "method-head?" (letrec ((method-head? (lambda (nm) (let fnrec8830 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 1))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 0 1)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt= "-" (jolt-invoke (var-deref "clojure.core" "subs") nm 1 2))))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 1 2))) and__25__auto)) and__25__auto)) and__25__auto)))))) method-head?) (let* ((_o$8831 (keyword #f "private")) (_o$8832 #t)) (jolt-hash-map _o$8831 _o$8832)))) + (def-var-with-meta! "jolt.analyzer" "method-head?" (letrec ((method-head? (lambda (nm) (let fnrec8852 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 1))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 0 1)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt= "-" (jolt-invoke (var-deref "clojure.core" "subs") nm 1 2))))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 1 2))) and__25__auto)) and__25__auto)) and__25__auto)))))) method-head?) (let* ((_o$8853 (keyword #f "private")) (_o$8854 #t)) (jolt-hash-map _o$8853 _o$8854)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-host-call" (letrec ((analyze-host-call (lambda (ctx hname items env) (let fnrec8833 ((ctx ctx) (hname hname) (items items) (env env)) (begin (if (< (jolt-count items) 2) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed member expression, expecting (.method target ...): " hname)) jolt-nil) (let* ((_o$8838 (keyword #f "op")) (_o$8839 (keyword #f "host-call")) (_o$8840 (keyword #f "method")) (_o$8841 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$8842 (keyword #f "target")) (_o$8843 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$8844 (keyword #f "args")) (_o$8845 (let* ((_a$8835 (var-deref "clojure.core" "mapv")) (_a$8836 (lambda (p__100_) (let fnrec8834 ((p__100_ p__100_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__100_ env)))) (_a$8837 (jolt-drop 2 items))) (jolt-invoke _a$8835 _a$8836 _a$8837)))) (jolt-hash-map _o$8838 _o$8839 _o$8840 _o$8841 _o$8842 _o$8843 _o$8844 _o$8845))))))) analyze-host-call) (let* ((_o$8846 (keyword #f "private")) (_o$8847 #t)) (jolt-hash-map _o$8846 _o$8847)))) + (def-var-with-meta! "jolt.analyzer" "analyze-host-call" (letrec ((analyze-host-call (lambda (ctx hname items env) (let fnrec8855 ((ctx ctx) (hname hname) (items items) (env env)) (begin (if (< (jolt-count items) 2) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed member expression, expecting (.method target ...): " hname)) jolt-nil) (let* ((_o$8860 (keyword #f "op")) (_o$8861 (keyword #f "host-call")) (_o$8862 (keyword #f "method")) (_o$8863 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$8864 (keyword #f "target")) (_o$8865 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$8866 (keyword #f "args")) (_o$8867 (let* ((_a$8857 (var-deref "clojure.core" "mapv")) (_a$8858 (lambda (p__100_) (let fnrec8856 ((p__100_ p__100_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__100_ env)))) (_a$8859 (jolt-drop 2 items))) (jolt-invoke _a$8857 _a$8858 _a$8859)))) (jolt-hash-map _o$8860 _o$8861 _o$8862 _o$8863 _o$8864 _o$8865 _o$8866 _o$8867))))))) analyze-host-call) (let* ((_o$8868 (keyword #f "private")) (_o$8869 #t)) (jolt-hash-map _o$8868 _o$8869)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "ctor-head?" (letrec ((ctor-head? (lambda (nm) (let fnrec8848 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 1))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "." (let* ((_a$8849 (var-deref "clojure.core" "subs")) (_a$8850 nm) (_a$8851 (jolt-dec (jolt-count nm))) (_a$8852 (jolt-count nm))) (jolt-invoke _a$8849 _a$8850 _a$8851 _a$8852))))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 0 1))) and__25__auto)) and__25__auto)))))) ctor-head?) (let* ((_o$8853 (keyword #f "private")) (_o$8854 #t)) (jolt-hash-map _o$8853 _o$8854)))) + (def-var-with-meta! "jolt.analyzer" "ctor-head?" (letrec ((ctor-head? (lambda (nm) (let fnrec8870 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 1))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "." (let* ((_a$8871 (var-deref "clojure.core" "subs")) (_a$8872 nm) (_a$8873 (jolt-dec (jolt-count nm))) (_a$8874 (jolt-count nm))) (jolt-invoke _a$8871 _a$8872 _a$8873 _a$8874))))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 0 1))) and__25__auto)) and__25__auto)))))) ctor-head?) (let* ((_o$8875 (keyword #f "private")) (_o$8876 #t)) (jolt-hash-map _o$8875 _o$8876)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-ctor" (letrec ((analyze-ctor (lambda (ctx class args env) (let fnrec8855 ((ctx ctx) (class class) (args args) (env env)) (jolt-invoke (var-deref "jolt.ir" "host-new") class (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__101_) (let fnrec8856 ((p__101_ p__101_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__101_ env))) args)))))) analyze-ctor) (let* ((_o$8857 (keyword #f "private")) (_o$8858 #t)) (jolt-hash-map _o$8857 _o$8858)))) + (def-var-with-meta! "jolt.analyzer" "analyze-ctor" (letrec ((analyze-ctor (lambda (ctx class args env) (let fnrec8877 ((ctx ctx) (class class) (args args) (env env)) (jolt-invoke (var-deref "jolt.ir" "host-new") class (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__101_) (let fnrec8878 ((p__101_ p__101_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__101_ env))) args)))))) analyze-ctor) (let* ((_o$8879 (keyword #f "private")) (_o$8880 #t)) (jolt-hash-map _o$8879 _o$8880)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-ffi-fn" (letrec ((analyze-ffi-fn (lambda (ctx items env) (let fnrec8859 ((ctx ctx) (items items) (env env)) (begin (if (jolt-not (<= 4 (jolt-count items) 5)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi/foreign-fn expects (foreign-fn \"sym\" [argtypes] rettype [:blocking])")) jolt-nil) (let* ((_o$8860 (keyword #f "op")) (_o$8861 (keyword #f "ffi-fn")) (_o$8862 (keyword #f "csym")) (_o$8863 (jolt-nth items 1)) (_o$8864 (keyword #f "argtypes")) (_o$8865 (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "clojure.core" "name") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 2)))) (_o$8866 (keyword #f "rettype")) (_o$8867 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$8868 (keyword #f "blocking")) (_o$8869 (let* ((and__25__auto (jolt= 5 (jolt-count items)))) (if (jolt-truthy? and__25__auto) (jolt= "blocking" (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 4))) and__25__auto)))) (jolt-hash-map _o$8860 _o$8861 _o$8862 _o$8863 _o$8864 _o$8865 _o$8866 _o$8867 _o$8868 _o$8869))))))) analyze-ffi-fn) (let* ((_o$8870 (keyword #f "private")) (_o$8871 #t)) (jolt-hash-map _o$8870 _o$8871)))) + (def-var-with-meta! "jolt.analyzer" "analyze-ffi-fn" (letrec ((analyze-ffi-fn (lambda (ctx items env) (let fnrec8881 ((ctx ctx) (items items) (env env)) (begin (if (jolt-not (<= 4 (jolt-count items) 5)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi/foreign-fn expects (foreign-fn \"sym\" [argtypes] rettype [:blocking])")) jolt-nil) (let* ((_o$8882 (keyword #f "op")) (_o$8883 (keyword #f "ffi-fn")) (_o$8884 (keyword #f "csym")) (_o$8885 (jolt-nth items 1)) (_o$8886 (keyword #f "argtypes")) (_o$8887 (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "clojure.core" "name") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 2)))) (_o$8888 (keyword #f "rettype")) (_o$8889 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$8890 (keyword #f "blocking")) (_o$8891 (let* ((and__25__auto (jolt= 5 (jolt-count items)))) (if (jolt-truthy? and__25__auto) (jolt= "blocking" (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 4))) and__25__auto)))) (jolt-hash-map _o$8882 _o$8883 _o$8884 _o$8885 _o$8886 _o$8887 _o$8888 _o$8889 _o$8890 _o$8891))))))) analyze-ffi-fn) (let* ((_o$8892 (keyword #f "private")) (_o$8893 #t)) (jolt-hash-map _o$8892 _o$8893)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-ffi-callable" (letrec ((analyze-ffi-callable (lambda (ctx items env) (let fnrec8872 ((ctx ctx) (items items) (env env)) (begin (if (jolt-not (<= 4 (jolt-count items) 5)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi/foreign-callable expects (foreign-callable f [argtypes] rettype [:collect-safe])")) jolt-nil) (let* ((_o$8873 (keyword #f "op")) (_o$8874 (keyword #f "ffi-callable")) (_o$8875 (keyword #f "fn")) (_o$8876 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$8877 (keyword #f "argtypes")) (_o$8878 (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "clojure.core" "name") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 2)))) (_o$8879 (keyword #f "rettype")) (_o$8880 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$8881 (keyword #f "collect-safe")) (_o$8882 (let* ((and__25__auto (jolt= 5 (jolt-count items)))) (if (jolt-truthy? and__25__auto) (jolt= "collect-safe" (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 4))) and__25__auto)))) (jolt-hash-map _o$8873 _o$8874 _o$8875 _o$8876 _o$8877 _o$8878 _o$8879 _o$8880 _o$8881 _o$8882))))))) analyze-ffi-callable) (let* ((_o$8883 (keyword #f "private")) (_o$8884 #t)) (jolt-hash-map _o$8883 _o$8884)))) + (def-var-with-meta! "jolt.analyzer" "analyze-ffi-callable" (letrec ((analyze-ffi-callable (lambda (ctx items env) (let fnrec8894 ((ctx ctx) (items items) (env env)) (begin (if (jolt-not (<= 4 (jolt-count items) 5)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi/foreign-callable expects (foreign-callable f [argtypes] rettype [:collect-safe])")) jolt-nil) (let* ((_o$8895 (keyword #f "op")) (_o$8896 (keyword #f "ffi-callable")) (_o$8897 (keyword #f "fn")) (_o$8898 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$8899 (keyword #f "argtypes")) (_o$8900 (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "clojure.core" "name") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 2)))) (_o$8901 (keyword #f "rettype")) (_o$8902 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$8903 (keyword #f "collect-safe")) (_o$8904 (let* ((and__25__auto (jolt= 5 (jolt-count items)))) (if (jolt-truthy? and__25__auto) (jolt= "collect-safe" (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 4))) and__25__auto)))) (jolt-hash-map _o$8895 _o$8896 _o$8897 _o$8898 _o$8899 _o$8900 _o$8901 _o$8902 _o$8903 _o$8904))))))) analyze-ffi-callable) (let* ((_o$8905 (keyword #f "private")) (_o$8906 #t)) (jolt-hash-map _o$8905 _o$8906)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-dot" (letrec ((analyze-dot (lambda (ctx items env) (let fnrec8885 ((ctx ctx) (items items) (env env)) (begin (if (< (jolt-count items) 3) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed (. target member ...) form")) jolt-nil) (let* ((member0 (jolt-nth items 2)) (items (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") member0)) (let* ((ml (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") member0)))) (let* ((_a$8889 (let* ((_o$8886 (jolt-nth items 0)) (_o$8887 (jolt-nth items 1)) (_o$8888 (jolt-first ml))) (jolt-vector _o$8886 _o$8887 _o$8888))) (_a$8890 (jolt-rest ml))) (jolt-into _a$8889 _a$8890))) items)) (target (jolt-nth items 1)) (member (jolt-nth items 2)) (class-target (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") target))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "jolt.analyzer" "local?") env (jolt-invoke (var-deref "jolt.host" "form-sym-name") target))) and__25__auto))) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx target))) (if (jolt= (keyword #f "class") (jolt-get r (keyword #f "kind"))) (jolt-get r (keyword #f "name")) jolt-nil)) jolt-nil))) (if (jolt-truthy? (let* ((and__25__auto class-target)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") member) and__25__auto))) (let* ((_a$8895 (var-deref "jolt.ir" "invoke")) (_a$8896 (jolt-invoke (var-deref "jolt.ir" "host-static") class-target (jolt-invoke (var-deref "jolt.host" "form-sym-name") member))) (_a$8897 (let* ((_a$8892 (var-deref "clojure.core" "mapv")) (_a$8893 (lambda (p__102_) (let fnrec8891 ((p__102_ p__102_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__102_ env)))) (_a$8894 (jolt-drop 3 items))) (jolt-invoke _a$8892 _a$8893 _a$8894)))) (jolt-invoke _a$8895 _a$8896 _a$8897)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") member)) (let* ((_o$8902 (keyword #f "op")) (_o$8903 (keyword #f "host-call")) (_o$8904 (keyword #f "method")) (_o$8905 (jolt-invoke (var-deref "jolt.host" "form-sym-name") member)) (_o$8906 (keyword #f "target")) (_o$8907 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx target env)) (_o$8908 (keyword #f "args")) (_o$8909 (let* ((_a$8899 (var-deref "clojure.core" "mapv")) (_a$8900 (lambda (p__103_) (let fnrec8898 ((p__103_ p__103_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__103_ env)))) (_a$8901 (jolt-drop 3 items))) (jolt-invoke _a$8899 _a$8900 _a$8901)))) (jolt-hash-map _o$8902 _o$8903 _o$8904 _o$8905 _o$8906 _o$8907 _o$8908 _o$8909)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-keyword?") member)) (let* ((_a$8910 (var-deref "jolt.ir" "invoke")) (_a$8911 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx member env)) (_a$8912 (jolt-vector (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)))) (jolt-invoke _a$8910 _a$8911 _a$8912)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "special form . (non-symbol member)") jolt-nil)))))))))) analyze-dot) (let* ((_o$8913 (keyword #f "private")) (_o$8914 #t)) (jolt-hash-map _o$8913 _o$8914)))) + (def-var-with-meta! "jolt.analyzer" "analyze-dot" (letrec ((analyze-dot (lambda (ctx items env) (let fnrec8907 ((ctx ctx) (items items) (env env)) (begin (if (< (jolt-count items) 3) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed (. target member ...) form")) jolt-nil) (let* ((member0 (jolt-nth items 2)) (items (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") member0)) (let* ((ml (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") member0)))) (let* ((_a$8911 (let* ((_o$8908 (jolt-nth items 0)) (_o$8909 (jolt-nth items 1)) (_o$8910 (jolt-first ml))) (jolt-vector _o$8908 _o$8909 _o$8910))) (_a$8912 (jolt-rest ml))) (jolt-into _a$8911 _a$8912))) items)) (target (jolt-nth items 1)) (member (jolt-nth items 2)) (class-target (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") target))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "jolt.analyzer" "local?") env (jolt-invoke (var-deref "jolt.host" "form-sym-name") target))) and__25__auto))) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx target))) (if (jolt= (keyword #f "class") (jolt-get r (keyword #f "kind"))) (jolt-get r (keyword #f "name")) jolt-nil)) jolt-nil))) (if (jolt-truthy? (let* ((and__25__auto class-target)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") member) and__25__auto))) (let* ((_a$8917 (var-deref "jolt.ir" "invoke")) (_a$8918 (jolt-invoke (var-deref "jolt.ir" "host-static") class-target (jolt-invoke (var-deref "jolt.host" "form-sym-name") member))) (_a$8919 (let* ((_a$8914 (var-deref "clojure.core" "mapv")) (_a$8915 (lambda (p__102_) (let fnrec8913 ((p__102_ p__102_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__102_ env)))) (_a$8916 (jolt-drop 3 items))) (jolt-invoke _a$8914 _a$8915 _a$8916)))) (jolt-invoke _a$8917 _a$8918 _a$8919)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") member)) (let* ((_o$8924 (keyword #f "op")) (_o$8925 (keyword #f "host-call")) (_o$8926 (keyword #f "method")) (_o$8927 (jolt-invoke (var-deref "jolt.host" "form-sym-name") member)) (_o$8928 (keyword #f "target")) (_o$8929 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx target env)) (_o$8930 (keyword #f "args")) (_o$8931 (let* ((_a$8921 (var-deref "clojure.core" "mapv")) (_a$8922 (lambda (p__103_) (let fnrec8920 ((p__103_ p__103_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__103_ env)))) (_a$8923 (jolt-drop 3 items))) (jolt-invoke _a$8921 _a$8922 _a$8923)))) (jolt-hash-map _o$8924 _o$8925 _o$8926 _o$8927 _o$8928 _o$8929 _o$8930 _o$8931)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-keyword?") member)) (let* ((_a$8932 (var-deref "jolt.ir" "invoke")) (_a$8933 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx member env)) (_a$8934 (jolt-vector (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)))) (jolt-invoke _a$8932 _a$8933 _a$8934)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "special form . (non-symbol member)") jolt-nil)))))))))) analyze-dot) (let* ((_o$8935 (keyword #f "private")) (_o$8936 #t)) (jolt-hash-map _o$8935 _o$8936)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-field" (letrec ((analyze-field (lambda (ctx hname items env) (let fnrec8915 ((ctx ctx) (hname hname) (items items) (env env)) (begin (if (< (jolt-count items) 2) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed (.-field target) form")) jolt-nil) (let* ((_o$8916 (keyword #f "op")) (_o$8917 (keyword #f "host-call")) (_o$8918 (keyword #f "method")) (_o$8919 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$8920 (keyword #f "target")) (_o$8921 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$8922 (keyword #f "args")) (_o$8923 (jolt-vector))) (jolt-hash-map _o$8916 _o$8917 _o$8918 _o$8919 _o$8920 _o$8921 _o$8922 _o$8923))))))) analyze-field) (let* ((_o$8924 (keyword #f "private")) (_o$8925 #t)) (jolt-hash-map _o$8924 _o$8925)))) + (def-var-with-meta! "jolt.analyzer" "analyze-field" (letrec ((analyze-field (lambda (ctx hname items env) (let fnrec8937 ((ctx ctx) (hname hname) (items items) (env env)) (begin (if (< (jolt-count items) 2) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed (.-field target) form")) jolt-nil) (let* ((_o$8938 (keyword #f "op")) (_o$8939 (keyword #f "host-call")) (_o$8940 (keyword #f "method")) (_o$8941 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$8942 (keyword #f "target")) (_o$8943 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$8944 (keyword #f "args")) (_o$8945 (jolt-vector))) (jolt-hash-map _o$8938 _o$8939 _o$8940 _o$8941 _o$8942 _o$8943 _o$8944 _o$8945))))))) analyze-field) (let* ((_o$8946 (keyword #f "private")) (_o$8947 #t)) (jolt-hash-map _o$8946 _o$8947)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-symbol" (letrec ((analyze-symbol (lambda (ctx form env) (let fnrec8926 ((ctx ctx) (form form) (env env)) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") form)) (ns (jolt-invoke (var-deref "jolt.host" "form-sym-ns") form))) (if (jolt-truthy? (let* ((and__25__auto (jolt-nil? ns))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "local?") env nm) and__25__auto))) (let* ((h (jolt-get (jolt-get env (keyword #f "hints")) nm))) (if (jolt-truthy? h) (jolt-assoc (jolt-invoke (var-deref "jolt.ir" "local") nm) (keyword #f "hint") h) (jolt-invoke (var-deref "jolt.ir" "local") nm))) (if (jolt-truthy? ns) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx form))) (if (jolt= (keyword #f "var") (jolt-get r (keyword #f "kind"))) (let* ((G__152 (let* ((_a$8927 (var-deref "jolt.ir" "var-ref")) (_a$8928 (jolt-get r (keyword #f "ns"))) (_a$8929 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8927 _a$8928 _a$8929)))) (let* ((G__153 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__152 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__152))) G__153)) (jolt-invoke (var-deref "jolt.ir" "host-static") ns nm))) (if (jolt-truthy? (keyword #f "else")) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx form))) (let* ((G__154 (jolt-get r (keyword #f "kind")))) (if (jolt= G__154 (keyword #f "var")) (let* ((G__155 (let* ((_a$8930 (var-deref "jolt.ir" "var-ref")) (_a$8931 (jolt-get r (keyword #f "ns"))) (_a$8932 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8930 _a$8931 _a$8932)))) (let* ((G__156 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__155 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__155))) G__156)) (if (jolt= G__154 (keyword #f "host")) (jolt-invoke (var-deref "jolt.ir" "host-ref") (jolt-get r (keyword #f "name"))) (if (jolt= G__154 (keyword #f "class")) (jolt-invoke (var-deref "jolt.ir" "const") (jolt-get r (keyword #f "name"))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "late-bind?") ctx)) (jolt-invoke (var-deref "jolt.ir" "var-ref") (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx) nm) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "Unable to resolve symbol: " nm " in this context")))))))) jolt-nil)))))))) analyze-symbol) (let* ((_o$8933 (keyword #f "private")) (_o$8934 #t)) (jolt-hash-map _o$8933 _o$8934)))) + (def-var-with-meta! "jolt.analyzer" "analyze-symbol" (letrec ((analyze-symbol (lambda (ctx form env) (let fnrec8948 ((ctx ctx) (form form) (env env)) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") form)) (ns (jolt-invoke (var-deref "jolt.host" "form-sym-ns") form))) (if (jolt-truthy? (let* ((and__25__auto (jolt-nil? ns))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "local?") env nm) and__25__auto))) (let* ((h (jolt-get (jolt-get env (keyword #f "hints")) nm))) (if (jolt-truthy? h) (jolt-assoc (jolt-invoke (var-deref "jolt.ir" "local") nm) (keyword #f "hint") h) (jolt-invoke (var-deref "jolt.ir" "local") nm))) (if (jolt-truthy? ns) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx form))) (if (jolt= (keyword #f "var") (jolt-get r (keyword #f "kind"))) (let* ((G__152 (let* ((_a$8949 (var-deref "jolt.ir" "var-ref")) (_a$8950 (jolt-get r (keyword #f "ns"))) (_a$8951 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8949 _a$8950 _a$8951)))) (let* ((G__153 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__152 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__152))) G__153)) (jolt-invoke (var-deref "jolt.ir" "host-static") ns nm))) (if (jolt-truthy? (keyword #f "else")) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx form))) (let* ((G__154 (jolt-get r (keyword #f "kind")))) (if (jolt= G__154 (keyword #f "var")) (let* ((G__155 (let* ((_a$8952 (var-deref "jolt.ir" "var-ref")) (_a$8953 (jolt-get r (keyword #f "ns"))) (_a$8954 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8952 _a$8953 _a$8954)))) (let* ((G__156 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__155 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__155))) G__156)) (if (jolt= G__154 (keyword #f "host")) (jolt-invoke (var-deref "jolt.ir" "host-ref") (jolt-get r (keyword #f "name"))) (if (jolt= G__154 (keyword #f "class")) (jolt-invoke (var-deref "jolt.ir" "const") (jolt-get r (keyword #f "name"))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "late-bind?") ctx)) (jolt-invoke (var-deref "jolt.ir" "var-ref") (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx) nm) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "Unable to resolve symbol: " nm " in this context")))))))) jolt-nil)))))))) analyze-symbol) (let* ((_o$8955 (keyword #f "private")) (_o$8956 #t)) (jolt-hash-map _o$8955 _o$8956)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "unchecked-arith" (letrec ((unchecked-arith (lambda (hname n) (let fnrec8935 ((hname hname) (n n)) (if (jolt= hname "+") "unchecked-add" (if (jolt= hname "*") "unchecked-multiply" (if (jolt= hname "-") (if (jolt= n 2) "unchecked-negate" "unchecked-subtract") (if (jolt= hname "inc") "unchecked-inc" (if (jolt= hname "dec") "unchecked-dec" (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))))))))) unchecked-arith) (let* ((_o$8936 (keyword #f "private")) (_o$8937 #t)) (jolt-hash-map _o$8936 _o$8937)))) + (def-var-with-meta! "jolt.analyzer" "unchecked-arith" (letrec ((unchecked-arith (lambda (hname n) (let fnrec8957 ((hname hname) (n n)) (if (jolt= hname "+") "unchecked-add" (if (jolt= hname "*") "unchecked-multiply" (if (jolt= hname "-") (if (jolt= n 2) "unchecked-negate" "unchecked-subtract") (if (jolt= hname "inc") "unchecked-inc" (if (jolt= hname "dec") "unchecked-dec" (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))))))))) unchecked-arith) (let* ((_o$8958 (keyword #f "private")) (_o$8959 #t)) (jolt-hash-map _o$8958 _o$8959)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "analyze-list" (letrec ((analyze-list (lambda (ctx form env) (let fnrec8938 ((ctx ctx) (form form) (env env)) (let* ((items (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") form)))) (if (jolt-zero? (jolt-count items)) (jolt-invoke (var-deref "jolt.ir" "quote-node") form) (let* ((head (jolt-first items)) (hname (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (jolt-nil? (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") head) jolt-nil)) (sf-name (let* ((or__26__auto hname)) (if (jolt-truthy? or__26__auto) or__26__auto (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "clojure.core" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)))) (if (jolt-truthy? and__25__auto) (jolt-contains? (var-deref "jolt.analyzer" "handled") (jolt-invoke (var-deref "jolt.host" "form-sym-name") head)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") head) jolt-nil)))) (shadowed (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "local?") env hname) and__25__auto))) (unm (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "unchecked-math?"))) (let* ((opn (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (jolt-not shadowed) and__25__auto))) hname (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (jolt= "clojure.core" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") head) jolt-nil)))) (if (jolt-truthy? opn) (jolt-invoke (var-deref "jolt.analyzer" "unchecked-arith") opn (jolt-count items)) jolt-nil)) jolt-nil))) (if (jolt-truthy? unm) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (let* ((_a$8939 (jolt-invoke (var-deref "clojure.core" "symbol") unm)) (_a$8940 (jolt-rest items))) (jolt-cons _a$8939 _a$8940)) env) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-contains? (var-deref "jolt.analyzer" "handled") sf-name)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-macro?") ctx head) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((node (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-invoke (var-deref "jolt.host" "form-expand-1") ctx form (jolt-invoke (var-deref "jolt.analyzer" "amp-env-map") env)) env)) (p (jolt-invoke (var-deref "jolt.host" "form-position") form))) (if (jolt-truthy? (let* ((and__25__auto p)) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))) and__25__auto))) (jolt-assoc node (keyword #f "pos") p) node)) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "jolt.ffi" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)))) (if (jolt-truthy? and__25__auto) (jolt= "__cfn" (jolt-invoke (var-deref "jolt.host" "form-sym-name") head)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-ffi-fn") ctx items env) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "jolt.ffi" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)))) (if (jolt-truthy? and__25__auto) (jolt= "__ccallable" (jolt-invoke (var-deref "jolt.host" "form-sym-name") head)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-ffi-callable") ctx items env) (if (jolt-truthy? (let* ((and__25__auto sf-name)) (if (jolt-truthy? and__25__auto) (jolt-contains? (var-deref "jolt.analyzer" "handled") sf-name) and__25__auto))) (let* ((node (jolt-invoke (var-deref "jolt.analyzer" "analyze-special") ctx sf-name items env)) (p (jolt-invoke (var-deref "jolt.host" "form-position") form))) (if (jolt-truthy? (let* ((and__25__auto p)) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))) and__25__auto))) (jolt-assoc node (keyword #f "pos") p) node)) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "method-head?") hname) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-host-call") ctx hname items env) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "ctor-head?") hname) and__25__auto)) and__25__auto))) (let* ((_a$8941 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$8942 ctx) (_a$8943 (jolt-invoke (var-deref "clojure.core" "subs") hname 0 (jolt-dec (jolt-count hname)))) (_a$8944 (jolt-rest items)) (_a$8945 env)) (jolt-invoke _a$8941 _a$8942 _a$8943 _a$8944 _a$8945)) (if (jolt-truthy? (let* ((and__25__auto (jolt= hname "new"))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= (jolt-count items) 2))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth items 1)) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((_a$8946 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$8947 ctx) (_a$8948 (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth items 1))) (_a$8949 (jolt-drop 2 items)) (_a$8950 env)) (jolt-invoke _a$8946 _a$8947 _a$8948 _a$8949 _a$8950)) (if (let* ((and__25__auto (jolt= hname "."))) (if (jolt-truthy? and__25__auto) (jolt-not shadowed) and__25__auto)) (jolt-invoke (var-deref "jolt.analyzer" "analyze-dot") ctx items env) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "field-head?") hname) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-field") ctx hname items env) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-special?") hname) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "special form " hname)) (if (jolt-truthy? (keyword #f "else")) (let* ((n (let* ((_a$8955 (var-deref "jolt.ir" "invoke")) (_a$8956 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx head env)) (_a$8957 (let* ((_a$8952 (var-deref "clojure.core" "mapv")) (_a$8953 (lambda (p__104_) (let fnrec8951 ((p__104_ p__104_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__104_ env)))) (_a$8954 (jolt-rest items))) (jolt-invoke _a$8952 _a$8953 _a$8954)))) (jolt-invoke _a$8955 _a$8956 _a$8957))) (p (jolt-invoke (var-deref "jolt.host" "form-position") form))) (if (jolt-truthy? p) (jolt-assoc n (keyword #f "pos") p) n)) jolt-nil))))))))))))))))))) analyze-list) (let* ((_o$8958 (keyword #f "private")) (_o$8959 #t)) (jolt-hash-map _o$8958 _o$8959)))) + (def-var-with-meta! "jolt.analyzer" "analyze-list" (letrec ((analyze-list (lambda (ctx form env) (let fnrec8960 ((ctx ctx) (form form) (env env)) (let* ((items (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") form)))) (if (jolt-zero? (jolt-count items)) (jolt-invoke (var-deref "jolt.ir" "quote-node") form) (let* ((head (jolt-first items)) (hname (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (jolt-nil? (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") head) jolt-nil)) (sf-name (let* ((or__26__auto hname)) (if (jolt-truthy? or__26__auto) or__26__auto (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "clojure.core" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)))) (if (jolt-truthy? and__25__auto) (jolt-contains? (var-deref "jolt.analyzer" "handled") (jolt-invoke (var-deref "jolt.host" "form-sym-name") head)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") head) jolt-nil)))) (shadowed (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "local?") env hname) and__25__auto))) (unm (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "unchecked-math?"))) (let* ((opn (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (jolt-not shadowed) and__25__auto))) hname (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (jolt= "clojure.core" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") head) jolt-nil)))) (if (jolt-truthy? opn) (jolt-invoke (var-deref "jolt.analyzer" "unchecked-arith") opn (jolt-count items)) jolt-nil)) jolt-nil))) (if (jolt-truthy? unm) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (let* ((_a$8961 (jolt-invoke (var-deref "clojure.core" "symbol") unm)) (_a$8962 (jolt-rest items))) (jolt-cons _a$8961 _a$8962)) env) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-contains? (var-deref "jolt.analyzer" "handled") sf-name)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-macro?") ctx head) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((node (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-invoke (var-deref "jolt.host" "form-expand-1") ctx form (jolt-invoke (var-deref "jolt.analyzer" "amp-env-map") env)) env)) (p (jolt-invoke (var-deref "jolt.host" "form-position") form))) (if (jolt-truthy? (let* ((and__25__auto p)) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))) and__25__auto))) (jolt-assoc node (keyword #f "pos") p) node)) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "jolt.ffi" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)))) (if (jolt-truthy? and__25__auto) (jolt= "__cfn" (jolt-invoke (var-deref "jolt.host" "form-sym-name") head)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-ffi-fn") ctx items env) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "jolt.ffi" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)))) (if (jolt-truthy? and__25__auto) (jolt= "__ccallable" (jolt-invoke (var-deref "jolt.host" "form-sym-name") head)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-ffi-callable") ctx items env) (if (jolt-truthy? (let* ((and__25__auto sf-name)) (if (jolt-truthy? and__25__auto) (jolt-contains? (var-deref "jolt.analyzer" "handled") sf-name) and__25__auto))) (let* ((node (jolt-invoke (var-deref "jolt.analyzer" "analyze-special") ctx sf-name items env)) (p (jolt-invoke (var-deref "jolt.host" "form-position") form))) (if (jolt-truthy? (let* ((and__25__auto p)) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))) and__25__auto))) (jolt-assoc node (keyword #f "pos") p) node)) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "method-head?") hname) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-host-call") ctx hname items env) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "ctor-head?") hname) and__25__auto)) and__25__auto))) (let* ((_a$8963 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$8964 ctx) (_a$8965 (jolt-invoke (var-deref "clojure.core" "subs") hname 0 (jolt-dec (jolt-count hname)))) (_a$8966 (jolt-rest items)) (_a$8967 env)) (jolt-invoke _a$8963 _a$8964 _a$8965 _a$8966 _a$8967)) (if (jolt-truthy? (let* ((and__25__auto (jolt= hname "new"))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= (jolt-count items) 2))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth items 1)) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((_a$8968 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$8969 ctx) (_a$8970 (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth items 1))) (_a$8971 (jolt-drop 2 items)) (_a$8972 env)) (jolt-invoke _a$8968 _a$8969 _a$8970 _a$8971 _a$8972)) (if (let* ((and__25__auto (jolt= hname "."))) (if (jolt-truthy? and__25__auto) (jolt-not shadowed) and__25__auto)) (jolt-invoke (var-deref "jolt.analyzer" "analyze-dot") ctx items env) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "field-head?") hname) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-field") ctx hname items env) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-special?") hname) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "special form " hname)) (if (jolt-truthy? (keyword #f "else")) (let* ((n (let* ((_a$8977 (var-deref "jolt.ir" "invoke")) (_a$8978 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx head env)) (_a$8979 (let* ((_a$8974 (var-deref "clojure.core" "mapv")) (_a$8975 (lambda (p__104_) (let fnrec8973 ((p__104_ p__104_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__104_ env)))) (_a$8976 (jolt-rest items))) (jolt-invoke _a$8974 _a$8975 _a$8976)))) (jolt-invoke _a$8977 _a$8978 _a$8979))) (p (jolt-invoke (var-deref "jolt.host" "form-position") form))) (if (jolt-truthy? p) (jolt-assoc n (keyword #f "pos") p) n)) jolt-nil))))))))))))))))))) analyze-list) (let* ((_o$8980 (keyword #f "private")) (_o$8981 #t)) (jolt-hash-map _o$8980 _o$8981)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "with-coll-meta" (letrec ((with-coll-meta (lambda (ctx form env node) (let fnrec8960 ((ctx ctx) (form form) (env env) (node node)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-coll-meta") form))) (if (jolt-nil? m) node (let* ((_a$8963 (var-deref "jolt.ir" "invoke")) (_a$8964 (jolt-invoke (var-deref "jolt.ir" "var-ref") "clojure.core" "with-meta")) (_a$8965 (let* ((_o$8961 node) (_o$8962 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx m env))) (jolt-vector _o$8961 _o$8962)))) (jolt-invoke _a$8963 _a$8964 _a$8965)))))))) with-coll-meta) (let* ((_o$8966 (keyword #f "private")) (_o$8967 #t)) (jolt-hash-map _o$8966 _o$8967)))) + (def-var-with-meta! "jolt.analyzer" "with-coll-meta" (letrec ((with-coll-meta (lambda (ctx form env node) (let fnrec8982 ((ctx ctx) (form form) (env env) (node node)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-coll-meta") form))) (if (jolt-nil? m) node (let* ((_a$8985 (var-deref "jolt.ir" "invoke")) (_a$8986 (jolt-invoke (var-deref "jolt.ir" "var-ref") "clojure.core" "with-meta")) (_a$8987 (let* ((_o$8983 node) (_o$8984 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx m env))) (jolt-vector _o$8983 _o$8984)))) (jolt-invoke _a$8985 _a$8986 _a$8987)))))))) with-coll-meta) (let* ((_o$8988 (keyword #f "private")) (_o$8989 #t)) (jolt-hash-map _o$8988 _o$8989)))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze" (letrec ((analyze (case-lambda ((ctx form) (let fnrec8968 ((ctx ctx) (form form)) (analyze ctx form (jolt-invoke (var-deref "jolt.analyzer" "empty-env"))))) ((ctx form env) (let fnrec8969 ((ctx ctx) (form form) (env env)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-literal?") form)) (jolt-invoke (var-deref "jolt.ir" "const") form) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") form)) (jolt-invoke (var-deref "jolt.analyzer" "analyze-symbol") ctx form env) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-vec?") form)) (jolt-invoke (var-deref "jolt.analyzer" "with-coll-meta") ctx form env (jolt-invoke (var-deref "jolt.ir" "vector-node") (let* ((_a$8971 (var-deref "clojure.core" "mapv")) (_a$8972 (lambda (p__105_) (let fnrec8970 ((p__105_ p__105_)) (analyze ctx p__105_ env)))) (_a$8973 (jolt-invoke (var-deref "jolt.host" "form-vec-items") form))) (jolt-invoke _a$8971 _a$8972 _a$8973)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-map?") form)) (jolt-invoke (var-deref "jolt.analyzer" "with-coll-meta") ctx form env (jolt-invoke (var-deref "jolt.ir" "map-node") (let* ((_a$8977 (var-deref "clojure.core" "mapv")) (_a$8978 (lambda (p) (let fnrec8974 ((p p)) (let* ((_o$8975 (analyze ctx (jolt-first p) env)) (_o$8976 (analyze ctx (jolt-invoke (var-deref "clojure.core" "second") p) env))) (jolt-vector _o$8975 _o$8976))))) (_a$8979 (jolt-invoke (var-deref "jolt.host" "form-map-pairs") form))) (jolt-invoke _a$8977 _a$8978 _a$8979)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-set?") form)) (jolt-invoke (var-deref "jolt.analyzer" "with-coll-meta") ctx form env (jolt-invoke (var-deref "jolt.ir" "set-node") (let* ((_a$8981 (var-deref "clojure.core" "mapv")) (_a$8982 (lambda (p__106_) (let fnrec8980 ((p__106_ p__106_)) (analyze ctx p__106_ env)))) (_a$8983 (jolt-invoke (var-deref "jolt.host" "form-set-items") form))) (jolt-invoke _a$8981 _a$8982 _a$8983)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") form)) (jolt-invoke (var-deref "jolt.analyzer" "analyze-list") ctx form env) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-regex?") form)) (let* ((_o$8984 (keyword #f "op")) (_o$8985 (keyword #f "regex")) (_o$8986 (keyword #f "source")) (_o$8987 (jolt-invoke (var-deref "jolt.host" "form-regex-source") form))) (jolt-hash-map _o$8984 _o$8985 _o$8986 _o$8987)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-inst?") form)) (let* ((_o$8988 (keyword #f "op")) (_o$8989 (keyword #f "inst")) (_o$8990 (keyword #f "source")) (_o$8991 (jolt-invoke (var-deref "jolt.host" "form-inst-source") form))) (jolt-hash-map _o$8988 _o$8989 _o$8990 _o$8991)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-uuid?") form)) (let* ((_o$8992 (keyword #f "op")) (_o$8993 (keyword #f "uuid")) (_o$8994 (keyword #f "source")) (_o$8995 (jolt-invoke (var-deref "jolt.host" "form-uuid-source") form))) (jolt-hash-map _o$8992 _o$8993 _o$8994 _o$8995)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-bigdec?") form)) (let* ((_o$8996 (keyword #f "op")) (_o$8997 (keyword #f "bigdec")) (_o$8998 (keyword #f "source")) (_o$8999 (jolt-invoke (var-deref "jolt.host" "form-bigdec-source") form))) (jolt-hash-map _o$8996 _o$8997 _o$8998 _o$8999)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-ns-value?") form)) (let* ((_o$9000 (keyword #f "op")) (_o$9001 (keyword #f "the-ns")) (_o$9002 (keyword #f "name")) (_o$9003 (jolt-invoke (var-deref "jolt.host" "form-ns-value-name") form))) (jolt-hash-map _o$9000 _o$9001 _o$9002 _o$9003)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-var-value?") form)) (let* ((_a$9004 (var-deref "jolt.ir" "the-var")) (_a$9005 (jolt-invoke (var-deref "jolt.host" "form-var-value-ns") form)) (_a$9006 (jolt-invoke (var-deref "jolt.host" "form-var-value-name") form))) (jolt-invoke _a$9004 _a$9005 _a$9006)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "unsupported form") jolt-nil)))))))))))))))))) analyze))) + (def-var! "jolt.analyzer" "analyze" (letrec ((analyze (case-lambda ((ctx form) (let fnrec8990 ((ctx ctx) (form form)) (analyze ctx form (jolt-invoke (var-deref "jolt.analyzer" "empty-env"))))) ((ctx form env) (let fnrec8991 ((ctx ctx) (form form) (env env)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-literal?") form)) (jolt-invoke (var-deref "jolt.ir" "const") form) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") form)) (jolt-invoke (var-deref "jolt.analyzer" "analyze-symbol") ctx form env) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-vec?") form)) (jolt-invoke (var-deref "jolt.analyzer" "with-coll-meta") ctx form env (jolt-invoke (var-deref "jolt.ir" "vector-node") (let* ((_a$8993 (var-deref "clojure.core" "mapv")) (_a$8994 (lambda (p__105_) (let fnrec8992 ((p__105_ p__105_)) (analyze ctx p__105_ env)))) (_a$8995 (jolt-invoke (var-deref "jolt.host" "form-vec-items") form))) (jolt-invoke _a$8993 _a$8994 _a$8995)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-map?") form)) (jolt-invoke (var-deref "jolt.analyzer" "with-coll-meta") ctx form env (jolt-invoke (var-deref "jolt.ir" "map-node") (let* ((_a$8999 (var-deref "clojure.core" "mapv")) (_a$9000 (lambda (p) (let fnrec8996 ((p p)) (let* ((_o$8997 (analyze ctx (jolt-first p) env)) (_o$8998 (analyze ctx (jolt-invoke (var-deref "clojure.core" "second") p) env))) (jolt-vector _o$8997 _o$8998))))) (_a$9001 (jolt-invoke (var-deref "jolt.host" "form-map-pairs") form))) (jolt-invoke _a$8999 _a$9000 _a$9001)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-set?") form)) (jolt-invoke (var-deref "jolt.analyzer" "with-coll-meta") ctx form env (jolt-invoke (var-deref "jolt.ir" "set-node") (let* ((_a$9003 (var-deref "clojure.core" "mapv")) (_a$9004 (lambda (p__106_) (let fnrec9002 ((p__106_ p__106_)) (analyze ctx p__106_ env)))) (_a$9005 (jolt-invoke (var-deref "jolt.host" "form-set-items") form))) (jolt-invoke _a$9003 _a$9004 _a$9005)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") form)) (jolt-invoke (var-deref "jolt.analyzer" "analyze-list") ctx form env) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-regex?") form)) (let* ((_o$9006 (keyword #f "op")) (_o$9007 (keyword #f "regex")) (_o$9008 (keyword #f "source")) (_o$9009 (jolt-invoke (var-deref "jolt.host" "form-regex-source") form))) (jolt-hash-map _o$9006 _o$9007 _o$9008 _o$9009)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-inst?") form)) (let* ((_o$9010 (keyword #f "op")) (_o$9011 (keyword #f "inst")) (_o$9012 (keyword #f "source")) (_o$9013 (jolt-invoke (var-deref "jolt.host" "form-inst-source") form))) (jolt-hash-map _o$9010 _o$9011 _o$9012 _o$9013)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-uuid?") form)) (let* ((_o$9014 (keyword #f "op")) (_o$9015 (keyword #f "uuid")) (_o$9016 (keyword #f "source")) (_o$9017 (jolt-invoke (var-deref "jolt.host" "form-uuid-source") form))) (jolt-hash-map _o$9014 _o$9015 _o$9016 _o$9017)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-bigdec?") form)) (let* ((_o$9018 (keyword #f "op")) (_o$9019 (keyword #f "bigdec")) (_o$9020 (keyword #f "source")) (_o$9021 (jolt-invoke (var-deref "jolt.host" "form-bigdec-source") form))) (jolt-hash-map _o$9018 _o$9019 _o$9020 _o$9021)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-ns-value?") form)) (let* ((_o$9022 (keyword #f "op")) (_o$9023 (keyword #f "the-ns")) (_o$9024 (keyword #f "name")) (_o$9025 (jolt-invoke (var-deref "jolt.host" "form-ns-value-name") form))) (jolt-hash-map _o$9022 _o$9023 _o$9024 _o$9025)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-var-value?") form)) (let* ((_a$9026 (var-deref "jolt.ir" "the-var")) (_a$9027 (jolt-invoke (var-deref "jolt.host" "form-var-value-ns") form)) (_a$9028 (jolt-invoke (var-deref "jolt.host" "form-var-value-name") form))) (jolt-invoke _a$9026 _a$9027 _a$9028)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "unsupported form") jolt-nil)))))))))))))))))) analyze))) (guard (e (#t #f)) (def-var-with-meta! "jolt.backend-scheme" "native-ops" (let* ((_o$7160 "+") (_o$7161 "+") (_o$7162 "-") (_o$7163 "-") (_o$7164 "*") (_o$7165 "*") (_o$7166 "/") (_o$7167 "/") (_o$7168 "<") (_o$7169 "<") (_o$7170 ">") (_o$7171 ">") (_o$7172 "<=") (_o$7173 "<=") (_o$7174 ">=") (_o$7175 ">=") (_o$7176 "=") (_o$7177 "jolt=") (_o$7178 "inc") (_o$7179 "jolt-inc") (_o$7180 "dec") (_o$7181 "jolt-dec") (_o$7182 "not") (_o$7183 "jolt-not") (_o$7184 "min") (_o$7185 "min") (_o$7186 "max") (_o$7187 "max") (_o$7188 "mod") (_o$7189 "modulo") (_o$7190 "rem") (_o$7191 "remainder") (_o$7192 "quot") (_o$7193 "quotient") (_o$7194 "vector") (_o$7195 "jolt-vector") (_o$7196 "hash-map") (_o$7197 "jolt-hash-map-fn") (_o$7198 "hash-set") (_o$7199 "jolt-hash-set") (_o$7200 "conj") (_o$7201 "jolt-conj") (_o$7202 "get") (_o$7203 "jolt-get") (_o$7204 "nth") (_o$7205 "jolt-nth") (_o$7206 "count") (_o$7207 "jolt-count") (_o$7208 "assoc") (_o$7209 "jolt-assoc") (_o$7210 "dissoc") (_o$7211 "jolt-dissoc") (_o$7212 "contains?") (_o$7213 "jolt-contains?") (_o$7214 "empty?") (_o$7215 "jolt-empty?") (_o$7216 "peek") (_o$7217 "jolt-peek") (_o$7218 "pop") (_o$7219 "jolt-pop") (_o$7220 "first") (_o$7221 "jolt-first") (_o$7222 "rest") (_o$7223 "jolt-rest") (_o$7224 "next") (_o$7225 "jolt-next") (_o$7226 "seq") (_o$7227 "jolt-seq") (_o$7228 "cons") (_o$7229 "jolt-cons") (_o$7230 "list") (_o$7231 "jolt-list") (_o$7232 "reverse") (_o$7233 "jolt-reverse") (_o$7234 "last") (_o$7235 "jolt-last") (_o$7236 "map") (_o$7237 "jolt-map") (_o$7238 "filter") (_o$7239 "jolt-filter") (_o$7240 "remove") (_o$7241 "jolt-remove") (_o$7242 "reduce") (_o$7243 "jolt-reduce") (_o$7244 "into") (_o$7245 "jolt-into") (_o$7246 "concat") (_o$7247 "jolt-concat") (_o$7248 "apply") (_o$7249 "jolt-apply") (_o$7250 "range") (_o$7251 "jolt-range") (_o$7252 "take") (_o$7253 "jolt-take") (_o$7254 "drop") (_o$7255 "jolt-drop") (_o$7256 "keys") (_o$7257 "jolt-keys") (_o$7258 "vals") (_o$7259 "jolt-vals") (_o$7260 "even?") (_o$7261 "jolt-even?") (_o$7262 "odd?") (_o$7263 "jolt-odd?") (_o$7264 "pos?") (_o$7265 "jolt-pos?") (_o$7266 "neg?") (_o$7267 "jolt-neg?") (_o$7268 "zero?") (_o$7269 "jolt-zero?") (_o$7270 "identity") (_o$7271 "jolt-identity") (_o$7272 "nil?") (_o$7273 "jolt-nil?") (_o$7274 "some?") (_o$7275 "jolt-some?") (_o$7276 "ex-info") (_o$7277 "jolt-ex-info") (_o$7278 "bit-and") (_o$7279 "bitwise-and") (_o$7280 "bit-or") (_o$7281 "bitwise-ior") (_o$7282 "bit-xor") (_o$7283 "bitwise-xor") (_o$7284 "bit-not") (_o$7285 "bitwise-not") (_o$7286 "bit-shift-left") (_o$7287 "jolt-bit-shift-left") (_o$7288 "bit-shift-right") (_o$7289 "jolt-bit-shift-right") (_o$7290 "unsigned-bit-shift-right") (_o$7291 "jolt-unsigned-bit-shift-right") (_o$7292 "protocol-dispatch1") (_o$7293 "protocol-dispatch1") (_o$7294 "protocol-dispatch2") (_o$7295 "protocol-dispatch2") (_o$7296 "protocol-dispatch3") (_o$7297 "protocol-dispatch3")) (jolt-hash-map _o$7160 _o$7161 _o$7162 _o$7163 _o$7164 _o$7165 _o$7166 _o$7167 _o$7168 _o$7169 _o$7170 _o$7171 _o$7172 _o$7173 _o$7174 _o$7175 _o$7176 _o$7177 _o$7178 _o$7179 _o$7180 _o$7181 _o$7182 _o$7183 _o$7184 _o$7185 _o$7186 _o$7187 _o$7188 _o$7189 _o$7190 _o$7191 _o$7192 _o$7193 _o$7194 _o$7195 _o$7196 _o$7197 _o$7198 _o$7199 _o$7200 _o$7201 _o$7202 _o$7203 _o$7204 _o$7205 _o$7206 _o$7207 _o$7208 _o$7209 _o$7210 _o$7211 _o$7212 _o$7213 _o$7214 _o$7215 _o$7216 _o$7217 _o$7218 _o$7219 _o$7220 _o$7221 _o$7222 _o$7223 _o$7224 _o$7225 _o$7226 _o$7227 _o$7228 _o$7229 _o$7230 _o$7231 _o$7232 _o$7233 _o$7234 _o$7235 _o$7236 _o$7237 _o$7238 _o$7239 _o$7240 _o$7241 _o$7242 _o$7243 _o$7244 _o$7245 _o$7246 _o$7247 _o$7248 _o$7249 _o$7250 _o$7251 _o$7252 _o$7253 _o$7254 _o$7255 _o$7256 _o$7257 _o$7258 _o$7259 _o$7260 _o$7261 _o$7262 _o$7263 _o$7264 _o$7265 _o$7266 _o$7267 _o$7268 _o$7269 _o$7270 _o$7271 _o$7272 _o$7273 _o$7274 _o$7275 _o$7276 _o$7277 _o$7278 _o$7279 _o$7280 _o$7281 _o$7282 _o$7283 _o$7284 _o$7285 _o$7286 _o$7287 _o$7288 _o$7289 _o$7290 _o$7291 _o$7292 _o$7293 _o$7294 _o$7295 _o$7296 _o$7297)) (let* ((_o$7298 (keyword #f "private")) (_o$7299 #t)) (jolt-hash-map _o$7298 _o$7299)))) (guard (e (#t #f)) @@ -161,119 +161,127 @@ (guard (e (#t #f)) (def-var! "jolt.backend-scheme" "direct-link-reset!" (letrec ((direct-link-reset! (lambda () (let fnrec7598 () (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "direct-link-defined") (jolt-hash-set)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "direct-link-fns") (jolt-hash-set))))))) direct-link-reset!))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "dl-munge" (letrec ((dl-munge (lambda (s) (let fnrec7599 ((s s)) (jolt-invoke (var-deref "clojure.string" "replace") (jolt-invoke (var-deref "clojure.string" "replace") (jolt-invoke (var-deref "clojure.string" "replace") s "$" "_D_") "#" "_H_") "'" "_Q_"))))) dl-munge) (let* ((_o$7600 (keyword #f "private")) (_o$7601 #t)) (jolt-hash-map _o$7600 _o$7601)))) + (def-var! "jolt.backend-scheme" "var-cache?" (jolt-invoke (var-deref "clojure.core" "atom") #f))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "dl-name" (letrec ((dl-name (lambda (ns nm) (let fnrec7602 ((ns ns) (nm nm)) (let* ((_a$7603 (var-deref "clojure.core" "str")) (_a$7604 "jv$") (_a$7605 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") ns)) (_a$7606 "$") (_a$7607 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") nm))) (jolt-invoke _a$7603 _a$7604 _a$7605 _a$7606 _a$7607)))))) dl-name) (let* ((_o$7608 (keyword #f "private")) (_o$7609 #t)) (jolt-hash-map _o$7608 _o$7609)))) + (def-var! "jolt.backend-scheme" "set-var-cache!" (letrec ((set-var-cache! (lambda (on) (let fnrec7599 ((on on)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "var-cache?") on))))) set-var-cache!))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "dl-fqn" (letrec ((dl-fqn (lambda (ns nm) (let fnrec7610 ((ns ns) (nm nm)) (jolt-invoke (var-deref "clojure.core" "str") ns "/" nm))))) dl-fqn) (let* ((_o$7611 (keyword #f "private")) (_o$7612 #t)) (jolt-hash-map _o$7611 _o$7612)))) + (def-var-with-meta! "jolt.backend-scheme" "dl-munge" (letrec ((dl-munge (lambda (s) (let fnrec7600 ((s s)) (jolt-invoke (var-deref "clojure.string" "replace") (jolt-invoke (var-deref "clojure.string" "replace") (jolt-invoke (var-deref "clojure.string" "replace") s "$" "_D_") "#" "_H_") "'" "_Q_"))))) dl-munge) (let* ((_o$7601 (keyword #f "private")) (_o$7602 #t)) (jolt-hash-map _o$7601 _o$7602)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "direct-linkable?" (letrec ((direct-linkable? (lambda (ns nm) (let fnrec7613 ((ns ns) (nm nm)) (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link?")))) (if (jolt-truthy? and__25__auto) (let* ((_a$7614 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-defined"))) (_a$7615 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$7614 _a$7615)) and__25__auto)))))) direct-linkable?) (let* ((_o$7616 (keyword #f "private")) (_o$7617 #t)) (jolt-hash-map _o$7616 _o$7617)))) + (def-var-with-meta! "jolt.backend-scheme" "dl-name" (letrec ((dl-name (lambda (ns nm) (let fnrec7603 ((ns ns) (nm nm)) (let* ((_a$7604 (var-deref "clojure.core" "str")) (_a$7605 "jv$") (_a$7606 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") ns)) (_a$7607 "$") (_a$7608 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") nm))) (jolt-invoke _a$7604 _a$7605 _a$7606 _a$7607 _a$7608)))))) dl-name) (let* ((_o$7609 (keyword #f "private")) (_o$7610 #t)) (jolt-hash-map _o$7609 _o$7610)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "direct-link-fn?" (letrec ((direct-link-fn? (lambda (ns nm) (let fnrec7618 ((ns ns) (nm nm)) (let* ((_a$7619 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-fns"))) (_a$7620 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$7619 _a$7620)))))) direct-link-fn?) (let* ((_o$7621 (keyword #f "private")) (_o$7622 #t)) (jolt-hash-map _o$7621 _o$7622)))) + (def-var-with-meta! "jolt.backend-scheme" "dl-fqn" (letrec ((dl-fqn (lambda (ns nm) (let fnrec7611 ((ns ns) (nm nm)) (jolt-invoke (var-deref "clojure.core" "str") ns "/" nm))))) dl-fqn) (let* ((_o$7612 (keyword #f "private")) (_o$7613 #t)) (jolt-hash-map _o$7612 _o$7613)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "*recur-target*" jolt-nil (let* ((_o$7623 (keyword #f "dynamic")) (_o$7624 #t)) (jolt-hash-map _o$7623 _o$7624)))) + (def-var-with-meta! "jolt.backend-scheme" "direct-linkable?" (letrec ((direct-linkable? (lambda (ns nm) (let fnrec7614 ((ns ns) (nm nm)) (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link?")))) (if (jolt-truthy? and__25__auto) (let* ((_a$7615 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-defined"))) (_a$7616 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$7615 _a$7616)) and__25__auto)))))) direct-linkable?) (let* ((_o$7617 (keyword #f "private")) (_o$7618 #t)) (jolt-hash-map _o$7617 _o$7618)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "*known-procs*" (jolt-hash-set) (let* ((_o$7625 (keyword #f "dynamic")) (_o$7626 #t)) (jolt-hash-map _o$7625 _o$7626)))) + (def-var-with-meta! "jolt.backend-scheme" "direct-link-fn?" (letrec ((direct-link-fn? (lambda (ns nm) (let fnrec7619 ((ns ns) (nm nm)) (let* ((_a$7620 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-fns"))) (_a$7621 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$7620 _a$7621)))))) direct-link-fn?) (let* ((_o$7622 (keyword #f "private")) (_o$7623 #t)) (jolt-hash-map _o$7622 _o$7623)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "gensym-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$7627 (keyword #f "private")) (_o$7628 #t)) (jolt-hash-map _o$7627 _o$7628)))) + (def-var-with-meta! "jolt.backend-scheme" "*recur-target*" jolt-nil (let* ((_o$7624 (keyword #f "dynamic")) (_o$7625 #t)) (jolt-hash-map _o$7624 _o$7625)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "fresh-label" (letrec ((fresh-label (lambda (prefix) (let fnrec7629 ((prefix prefix)) (jolt-invoke (var-deref "clojure.core" "str") prefix (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.backend-scheme" "gensym-counter") jolt-inc)))))) fresh-label) (let* ((_o$7630 (keyword #f "private")) (_o$7631 #t)) (jolt-hash-map _o$7630 _o$7631)))) + (def-var-with-meta! "jolt.backend-scheme" "*known-procs*" (jolt-hash-set) (let* ((_o$7626 (keyword #f "dynamic")) (_o$7627 #t)) (jolt-hash-map _o$7626 _o$7627)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "devirt-cells" (jolt-invoke (var-deref "clojure.core" "atom") jolt-nil) (let* ((_o$7632 (keyword #f "private")) (_o$7633 #t)) (jolt-hash-map _o$7632 _o$7633)))) + (def-var-with-meta! "jolt.backend-scheme" "gensym-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$7628 (keyword #f "private")) (_o$7629 #t)) (jolt-hash-map _o$7628 _o$7629)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "scheme-reserved" (let* ((_o$7634 "if") (_o$7635 "begin") (_o$7636 "lambda") (_o$7637 "let") (_o$7638 "let*") (_o$7639 "letrec") (_o$7640 "letrec*") (_o$7641 "quote") (_o$7642 "quasiquote") (_o$7643 "unquote") (_o$7644 "set!") (_o$7645 "define") (_o$7646 "define-syntax") (_o$7647 "cond") (_o$7648 "case") (_o$7649 "when") (_o$7650 "unless") (_o$7651 "and") (_o$7652 "or") (_o$7653 "do") (_o$7654 "else") (_o$7655 "guard") (_o$7656 "parameterize") (_o$7657 "delay") (_o$7658 "values")) (jolt-hash-set _o$7634 _o$7635 _o$7636 _o$7637 _o$7638 _o$7639 _o$7640 _o$7641 _o$7642 _o$7643 _o$7644 _o$7645 _o$7646 _o$7647 _o$7648 _o$7649 _o$7650 _o$7651 _o$7652 _o$7653 _o$7654 _o$7655 _o$7656 _o$7657 _o$7658)) (let* ((_o$7659 (keyword #f "private")) (_o$7660 #t)) (jolt-hash-map _o$7659 _o$7660)))) + (def-var-with-meta! "jolt.backend-scheme" "fresh-label" (letrec ((fresh-label (lambda (prefix) (let fnrec7630 ((prefix prefix)) (jolt-invoke (var-deref "clojure.core" "str") prefix (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.backend-scheme" "gensym-counter") jolt-inc)))))) fresh-label) (let* ((_o$7631 (keyword #f "private")) (_o$7632 #t)) (jolt-hash-map _o$7631 _o$7632)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "bare-native-names" (jolt-invoke (var-deref "clojure.core" "set") (jolt-invoke (var-deref "clojure.core" "keep") (lambda (G__138) (let fnrec7661 ((G__138 G__138)) (let* ((G__139 G__138) (k (jolt-nth G__139 0 jolt-nil)) (v (jolt-nth G__139 1 jolt-nil))) (if (jolt= k v) k jolt-nil)))) (var-deref "jolt.backend-scheme" "native-ops"))) (let* ((_o$7662 (keyword #f "private")) (_o$7663 #t)) (jolt-hash-map _o$7662 _o$7663)))) + (def-var-with-meta! "jolt.backend-scheme" "cache-cells" (jolt-invoke (var-deref "clojure.core" "atom") jolt-nil) (let* ((_o$7633 (keyword #f "private")) (_o$7634 #t)) (jolt-hash-map _o$7633 _o$7634)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "munge-name" (letrec ((munge-name (lambda (s) (let fnrec7664 ((s s)) (let* ((s (jolt-invoke (var-deref "clojure.string" "replace") (jolt-invoke (var-deref "clojure.string" "replace") s "#" "_") "'" "_PRIME_"))) (if (let* ((or__26__auto (jolt-contains? (var-deref "jolt.backend-scheme" "scheme-reserved") s))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-contains? (var-deref "jolt.backend-scheme" "bare-native-names") s))) (jolt-invoke (var-deref "clojure.core" "str") "_" s) s)))))) munge-name) (let* ((_o$7665 (keyword #f "private")) (_o$7666 #t)) (jolt-hash-map _o$7665 _o$7666)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-with-cells" (letrec ((emit-with-cells (lambda (emit-thunk) (let fnrec7635 ((emit-thunk emit-thunk)) (let* ((cells (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))) (prev (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "cache-cells"))) (_ (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "cache-cells") cells)) (raw (jolt-invoke emit-thunk)) (_ (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "cache-cells") prev))) (if (jolt-truthy? (jolt-seq (jolt-invoke (var-deref "clojure.core" "deref") cells))) (jolt-invoke (var-deref "clojure.core" "str") "(let (" (jolt-invoke (var-deref "clojure.string" "join") " " (let* ((_a$7637 (lambda (c) (let fnrec7636 ((c c)) (jolt-invoke (var-deref "clojure.core" "str") "(" c " #f)")))) (_a$7638 (jolt-invoke (var-deref "clojure.core" "deref") cells))) (jolt-map _a$7637 _a$7638))) ") " raw ")") raw)))))) emit-with-cells) (let* ((_o$7639 (keyword #f "private")) (_o$7640 #t)) (jolt-hash-map _o$7639 _o$7640)))) +(guard (e (#t #f)) + (def-var-with-meta! "jolt.backend-scheme" "scheme-reserved" (let* ((_o$7641 "if") (_o$7642 "begin") (_o$7643 "lambda") (_o$7644 "let") (_o$7645 "let*") (_o$7646 "letrec") (_o$7647 "letrec*") (_o$7648 "quote") (_o$7649 "quasiquote") (_o$7650 "unquote") (_o$7651 "set!") (_o$7652 "define") (_o$7653 "define-syntax") (_o$7654 "cond") (_o$7655 "case") (_o$7656 "when") (_o$7657 "unless") (_o$7658 "and") (_o$7659 "or") (_o$7660 "do") (_o$7661 "else") (_o$7662 "guard") (_o$7663 "parameterize") (_o$7664 "delay") (_o$7665 "values")) (jolt-hash-set _o$7641 _o$7642 _o$7643 _o$7644 _o$7645 _o$7646 _o$7647 _o$7648 _o$7649 _o$7650 _o$7651 _o$7652 _o$7653 _o$7654 _o$7655 _o$7656 _o$7657 _o$7658 _o$7659 _o$7660 _o$7661 _o$7662 _o$7663 _o$7664 _o$7665)) (let* ((_o$7666 (keyword #f "private")) (_o$7667 #t)) (jolt-hash-map _o$7666 _o$7667)))) +(guard (e (#t #f)) + (def-var-with-meta! "jolt.backend-scheme" "bare-native-names" (jolt-invoke (var-deref "clojure.core" "set") (jolt-invoke (var-deref "clojure.core" "keep") (lambda (G__138) (let fnrec7668 ((G__138 G__138)) (let* ((G__139 G__138) (k (jolt-nth G__139 0 jolt-nil)) (v (jolt-nth G__139 1 jolt-nil))) (if (jolt= k v) k jolt-nil)))) (var-deref "jolt.backend-scheme" "native-ops"))) (let* ((_o$7669 (keyword #f "private")) (_o$7670 #t)) (jolt-hash-map _o$7669 _o$7670)))) +(guard (e (#t #f)) + (def-var-with-meta! "jolt.backend-scheme" "munge-name" (letrec ((munge-name (lambda (s) (let fnrec7671 ((s s)) (let* ((s (jolt-invoke (var-deref "clojure.string" "replace") (jolt-invoke (var-deref "clojure.string" "replace") s "#" "_") "'" "_PRIME_"))) (if (let* ((or__26__auto (jolt-contains? (var-deref "jolt.backend-scheme" "scheme-reserved") s))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-contains? (var-deref "jolt.backend-scheme" "bare-native-names") s))) (jolt-invoke (var-deref "clojure.core" "str") "_" s) s)))))) munge-name) (let* ((_o$7672 (keyword #f "private")) (_o$7673 #t)) (jolt-hash-map _o$7672 _o$7673)))) (guard (e (#t #f)) (declare-var! "jolt.backend-scheme" "emit")) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "char-escape" (letrec ((char-escape (lambda (cp) (let fnrec7667 ((cp cp)) (if (jolt= cp 34) "\\\"" (if (jolt= cp 92) "\\\\" (if (jolt= cp 10) "\\n" (if (jolt= cp 9) "\\t" (if (jolt= cp 13) "\\r" (if (let* ((and__25__auto (>= cp 32))) (if (jolt-truthy? and__25__auto) (< cp 127) and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") (jolt-invoke (var-deref "clojure.core" "char") cp)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "str") "\\x" (jolt-invoke (var-deref "clojure.core" "format") "%x" cp) ";") jolt-nil))))))))))) char-escape) (let* ((_o$7668 (keyword #f "private")) (_o$7669 #t)) (jolt-hash-map _o$7668 _o$7669)))) + (def-var-with-meta! "jolt.backend-scheme" "char-escape" (letrec ((char-escape (lambda (cp) (let fnrec7674 ((cp cp)) (if (jolt= cp 34) "\\\"" (if (jolt= cp 92) "\\\\" (if (jolt= cp 10) "\\n" (if (jolt= cp 9) "\\t" (if (jolt= cp 13) "\\r" (if (let* ((and__25__auto (>= cp 32))) (if (jolt-truthy? and__25__auto) (< cp 127) and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") (jolt-invoke (var-deref "clojure.core" "char") cp)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "str") "\\x" (jolt-invoke (var-deref "clojure.core" "format") "%x" cp) ";") jolt-nil))))))))))) char-escape) (let* ((_o$7675 (keyword #f "private")) (_o$7676 #t)) (jolt-hash-map _o$7675 _o$7676)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "chez-str-lit" (letrec ((chez-str-lit (lambda (s) (let fnrec7670 ((s s)) (jolt-invoke (var-deref "clojure.core" "str") "\"" (jolt-apply (var-deref "clojure.core" "str") (jolt-map (lambda (c) (let fnrec7671 ((c c)) (jolt-invoke (var-deref "jolt.backend-scheme" "char-escape") (jolt-invoke (var-deref "clojure.core" "int") c)))) s)) "\""))))) chez-str-lit) (let* ((_o$7672 (keyword #f "private")) (_o$7673 #t)) (jolt-hash-map _o$7672 _o$7673)))) + (def-var-with-meta! "jolt.backend-scheme" "chez-str-lit" (letrec ((chez-str-lit (lambda (s) (let fnrec7677 ((s s)) (jolt-invoke (var-deref "clojure.core" "str") "\"" (jolt-apply (var-deref "clojure.core" "str") (jolt-map (lambda (c) (let fnrec7678 ((c c)) (jolt-invoke (var-deref "jolt.backend-scheme" "char-escape") (jolt-invoke (var-deref "clojure.core" "int") c)))) s)) "\""))))) chez-str-lit) (let* ((_o$7679 (keyword #f "private")) (_o$7680 #t)) (jolt-hash-map _o$7679 _o$7680)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-const" (letrec ((emit-const (lambda (v) (let fnrec7674 ((v v)) (if (jolt-nil? v) "jolt-nil" (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "boolean?") v)) (if (jolt-truthy? v) "#t" "#f") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") v)) (if (jolt= v +inf.0) "+inf.0" (if (jolt= v -inf.0) "-inf.0" (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "not=") v v)) "+nan.0" (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "float?") v)) (let* ((s (jolt-invoke (var-deref "clojure.core" "str") v))) (if (jolt-truthy? (let* ((or__26__auto (jolt-invoke (var-deref "clojure.string" "includes?") s "."))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-invoke (var-deref "clojure.string" "includes?") s "e")))) s (jolt-invoke (var-deref "clojure.core" "str") s ".0"))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "str") v) jolt-nil))))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") v)) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") v) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "keyword?") v)) (let* ((temp__16__auto (jolt-invoke (var-deref "clojure.core" "namespace") v))) (if (jolt-truthy? temp__16__auto) (let* ((kns temp__16__auto)) (let* ((_a$7675 (var-deref "clojure.core" "str")) (_a$7676 "(keyword ") (_a$7677 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") kns)) (_a$7678 " ") (_a$7679 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "clojure.core" "name") v))) (_a$7680 ")")) (jolt-invoke _a$7675 _a$7676 _a$7677 _a$7678 _a$7679 _a$7680))) (jolt-invoke (var-deref "clojure.core" "str") "(keyword #f " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "clojure.core" "name") v)) ")"))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-char?") v)) (jolt-invoke (var-deref "clojure.core" "str") "(integer->char " (jolt-invoke (var-deref "jolt.host" "form-char-code") v) ")") (if (jolt-truthy? (keyword #f "else")) (jolt-throw (let* ((_a$7681 (jolt-invoke (var-deref "clojure.core" "str") "emit-const: unsupported literal " (jolt-invoke (var-deref "clojure.core" "pr-str") v))) (_a$7682 (jolt-hash-map))) (jolt-ex-info _a$7681 _a$7682))) jolt-nil))))))))))) emit-const) (let* ((_o$7683 (keyword #f "private")) (_o$7684 #t)) (jolt-hash-map _o$7683 _o$7684)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-const" (letrec ((emit-const (lambda (v) (let fnrec7681 ((v v)) (if (jolt-nil? v) "jolt-nil" (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "boolean?") v)) (if (jolt-truthy? v) "#t" "#f") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") v)) (if (jolt= v +inf.0) "+inf.0" (if (jolt= v -inf.0) "-inf.0" (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "not=") v v)) "+nan.0" (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "float?") v)) (let* ((s (jolt-invoke (var-deref "clojure.core" "str") v))) (if (jolt-truthy? (let* ((or__26__auto (jolt-invoke (var-deref "clojure.string" "includes?") s "."))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-invoke (var-deref "clojure.string" "includes?") s "e")))) s (jolt-invoke (var-deref "clojure.core" "str") s ".0"))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "str") v) jolt-nil))))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") v)) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") v) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "keyword?") v)) (let* ((temp__16__auto (jolt-invoke (var-deref "clojure.core" "namespace") v))) (if (jolt-truthy? temp__16__auto) (let* ((kns temp__16__auto)) (let* ((_a$7682 (var-deref "clojure.core" "str")) (_a$7683 "(keyword ") (_a$7684 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") kns)) (_a$7685 " ") (_a$7686 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "clojure.core" "name") v))) (_a$7687 ")")) (jolt-invoke _a$7682 _a$7683 _a$7684 _a$7685 _a$7686 _a$7687))) (jolt-invoke (var-deref "clojure.core" "str") "(keyword #f " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "clojure.core" "name") v)) ")"))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-char?") v)) (jolt-invoke (var-deref "clojure.core" "str") "(integer->char " (jolt-invoke (var-deref "jolt.host" "form-char-code") v) ")") (if (jolt-truthy? (keyword #f "else")) (jolt-throw (let* ((_a$7688 (jolt-invoke (var-deref "clojure.core" "str") "emit-const: unsupported literal " (jolt-invoke (var-deref "clojure.core" "pr-str") v))) (_a$7689 (jolt-hash-map))) (jolt-ex-info _a$7688 _a$7689))) jolt-nil))))))))))) emit-const) (let* ((_o$7690 (keyword #f "private")) (_o$7691 #t)) (jolt-hash-map _o$7690 _o$7691)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-ordered" (letrec ((emit-ordered (lambda (ctor arg-strs) (let fnrec7685 ((ctor ctor) (arg-strs arg-strs)) (if (< (jolt-count arg-strs) 2) (jolt-invoke (var-deref "clojure.core" "str") "(" ctor (if (jolt-empty? arg-strs) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " arg-strs))) ")") (let* ((tmps (jolt-map (lambda (_) (let fnrec7686 ((_ _)) (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_o$"))) arg-strs)) (binds (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (t a) (let fnrec7687 ((t t) (a a)) (jolt-invoke (var-deref "clojure.core" "str") "(" t " " a ")"))) tmps arg-strs)))) (jolt-invoke (var-deref "clojure.core" "str") "(let* (" binds ") (" ctor " " (jolt-invoke (var-deref "clojure.string" "join") " " tmps) "))"))))))) emit-ordered) (let* ((_o$7688 (keyword #f "private")) (_o$7689 #t)) (jolt-hash-map _o$7688 _o$7689)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-ordered" (letrec ((emit-ordered (lambda (ctor arg-strs) (let fnrec7692 ((ctor ctor) (arg-strs arg-strs)) (if (< (jolt-count arg-strs) 2) (jolt-invoke (var-deref "clojure.core" "str") "(" ctor (if (jolt-empty? arg-strs) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " arg-strs))) ")") (let* ((tmps (jolt-map (lambda (_) (let fnrec7693 ((_ _)) (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_o$"))) arg-strs)) (binds (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (t a) (let fnrec7694 ((t t) (a a)) (jolt-invoke (var-deref "clojure.core" "str") "(" t " " a ")"))) tmps arg-strs)))) (jolt-invoke (var-deref "clojure.core" "str") "(let* (" binds ") (" ctor " " (jolt-invoke (var-deref "clojure.string" "join") " " tmps) "))"))))))) emit-ordered) (let* ((_o$7695 (keyword #f "private")) (_o$7696 #t)) (jolt-hash-map _o$7695 _o$7696)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "side-effect-free?" (letrec ((side-effect-free? (lambda (n) (let fnrec7690 ((n n)) (let* ((_a$7696 (let* ((_o$7691 (keyword #f "const")) (_o$7692 (keyword #f "local")) (_o$7693 (keyword #f "var")) (_o$7694 (keyword #f "the-var")) (_o$7695 (keyword #f "quote"))) (jolt-hash-set _o$7691 _o$7692 _o$7693 _o$7694 _o$7695))) (_a$7697 (jolt-get n (keyword #f "op")))) (jolt-contains? _a$7696 _a$7697)))))) side-effect-free?) (let* ((_o$7698 (keyword #f "private")) (_o$7699 #t)) (jolt-hash-map _o$7698 _o$7699)))) + (def-var-with-meta! "jolt.backend-scheme" "side-effect-free?" (letrec ((side-effect-free? (lambda (n) (let fnrec7697 ((n n)) (let* ((_a$7703 (let* ((_o$7698 (keyword #f "const")) (_o$7699 (keyword #f "local")) (_o$7700 (keyword #f "var")) (_o$7701 (keyword #f "the-var")) (_o$7702 (keyword #f "quote"))) (jolt-hash-set _o$7698 _o$7699 _o$7700 _o$7701 _o$7702))) (_a$7704 (jolt-get n (keyword #f "op")))) (jolt-contains? _a$7703 _a$7704)))))) side-effect-free?) (let* ((_o$7705 (keyword #f "private")) (_o$7706 #t)) (jolt-hash-map _o$7705 _o$7706)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "needs-order?" (letrec ((needs-order? (lambda (nodes) (let fnrec7700 ((nodes nodes)) (> (jolt-count (jolt-remove (var-deref "jolt.backend-scheme" "side-effect-free?") nodes)) 1))))) needs-order?) (let* ((_o$7701 (keyword #f "private")) (_o$7702 #t)) (jolt-hash-map _o$7701 _o$7702)))) + (def-var-with-meta! "jolt.backend-scheme" "needs-order?" (letrec ((needs-order? (lambda (nodes) (let fnrec7707 ((nodes nodes)) (> (jolt-count (jolt-remove (var-deref "jolt.backend-scheme" "side-effect-free?") nodes)) 1))))) needs-order?) (let* ((_o$7708 (keyword #f "private")) (_o$7709 #t)) (jolt-hash-map _o$7708 _o$7709)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "ordered-call" (letrec ((ordered-call (lambda (nodes strs build) (let fnrec7703 ((nodes nodes) (strs strs) (build build)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "needs-order?") nodes)) (let* ((tmps (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (_) (let fnrec7704 ((_ _)) (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_a$"))) strs)) (binds (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (t a) (let fnrec7705 ((t t) (a a)) (jolt-invoke (var-deref "clojure.core" "str") "(" t " " a ")"))) tmps strs)))) (jolt-invoke (var-deref "clojure.core" "str") "(let* (" binds ") " (jolt-invoke build tmps) ")")) (jolt-invoke build strs)))))) ordered-call) (let* ((_o$7706 (keyword #f "private")) (_o$7707 #t)) (jolt-hash-map _o$7706 _o$7707)))) + (def-var-with-meta! "jolt.backend-scheme" "ordered-call" (letrec ((ordered-call (lambda (nodes strs build) (let fnrec7710 ((nodes nodes) (strs strs) (build build)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "needs-order?") nodes)) (let* ((tmps (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (_) (let fnrec7711 ((_ _)) (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_a$"))) strs)) (binds (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (t a) (let fnrec7712 ((t t) (a a)) (jolt-invoke (var-deref "clojure.core" "str") "(" t " " a ")"))) tmps strs)))) (jolt-invoke (var-deref "clojure.core" "str") "(let* (" binds ") " (jolt-invoke build tmps) ")")) (jolt-invoke build strs)))))) ordered-call) (let* ((_o$7713 (keyword #f "private")) (_o$7714 #t)) (jolt-hash-map _o$7713 _o$7714)))) (guard (e (#t #f)) (declare-var! "jolt.backend-scheme" "emit-quoted")) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-quoted-map" (letrec ((emit-quoted-map (lambda (pairs) (let fnrec7708 ((pairs pairs)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-map " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-invoke (var-deref "clojure.core" "mapcat") (lambda (p) (let fnrec7709 ((p p)) (let* ((_o$7710 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 0))) (_o$7711 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 1)))) (jolt-vector _o$7710 _o$7711)))) pairs)) ")"))))) emit-quoted-map) (let* ((_o$7712 (keyword #f "private")) (_o$7713 #t)) (jolt-hash-map _o$7712 _o$7713)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-quoted-map" (letrec ((emit-quoted-map (lambda (pairs) (let fnrec7715 ((pairs pairs)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-map " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-invoke (var-deref "clojure.core" "mapcat") (lambda (p) (let fnrec7716 ((p p)) (let* ((_o$7717 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 0))) (_o$7718 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 1)))) (jolt-vector _o$7717 _o$7718)))) pairs)) ")"))))) emit-quoted-map) (let* ((_o$7719 (keyword #f "private")) (_o$7720 #t)) (jolt-hash-map _o$7719 _o$7720)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-quoted-map-value" (letrec ((emit-quoted-map-value (lambda (m) (let fnrec7714 ((m m)) (let* ((pairs (jolt-invoke (var-deref "clojure.core" "sort") (let* ((_a$7720 (lambda (k) (let fnrec7715 ((k k)) (let* ((_a$7716 (var-deref "clojure.core" "str")) (_a$7717 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") k)) (_a$7718 " ") (_a$7719 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get m k)))) (jolt-invoke _a$7716 _a$7717 _a$7718 _a$7719))))) (_a$7721 (jolt-keys m))) (jolt-map _a$7720 _a$7721))))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-map " (jolt-invoke (var-deref "clojure.string" "join") " " pairs) ")")))))) emit-quoted-map-value) (let* ((_o$7722 (keyword #f "private")) (_o$7723 #t)) (jolt-hash-map _o$7722 _o$7723)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-quoted-map-value" (letrec ((emit-quoted-map-value (lambda (m) (let fnrec7721 ((m m)) (let* ((pairs (jolt-invoke (var-deref "clojure.core" "sort") (let* ((_a$7727 (lambda (k) (let fnrec7722 ((k k)) (let* ((_a$7723 (var-deref "clojure.core" "str")) (_a$7724 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") k)) (_a$7725 " ") (_a$7726 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get m k)))) (jolt-invoke _a$7723 _a$7724 _a$7725 _a$7726))))) (_a$7728 (jolt-keys m))) (jolt-map _a$7727 _a$7728))))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-map " (jolt-invoke (var-deref "clojure.string" "join") " " pairs) ")")))))) emit-quoted-map-value) (let* ((_o$7729 (keyword #f "private")) (_o$7730 #t)) (jolt-hash-map _o$7729 _o$7730)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-quoted" (letrec ((emit-quoted (lambda (form) (let fnrec7724 ((form form)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-char?") form)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") form) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-literal?") form)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") form) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") form)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") form)) (sns (jolt-invoke (var-deref "jolt.host" "form-sym-ns") form)) (nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") form))) (if (jolt-truthy? (let* ((and__25__auto m)) (if (jolt-truthy? and__25__auto) (jolt-pos? (jolt-count m)) and__25__auto))) (let* ((_a$7725 (var-deref "clojure.core" "str")) (_a$7726 "(jolt-symbol/meta ") (_a$7727 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$7728 " ") (_a$7729 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7730 " ") (_a$7731 (emit-quoted m)) (_a$7732 ")")) (jolt-invoke _a$7725 _a$7726 _a$7727 _a$7728 _a$7729 _a$7730 _a$7731 _a$7732)) (let* ((_a$7733 (var-deref "clojure.core" "str")) (_a$7734 "(jolt-symbol ") (_a$7735 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$7736 " ") (_a$7737 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7738 ")")) (jolt-invoke _a$7733 _a$7734 _a$7735 _a$7736 _a$7737 _a$7738)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-set?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-set " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-invoke (var-deref "clojure.core" "sort") (jolt-map emit-quoted (jolt-invoke (var-deref "jolt.host" "form-set-items") form)))) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-list " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-quoted (jolt-invoke (var-deref "jolt.host" "form-elements") form))) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-vec?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-vector " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-quoted (jolt-invoke (var-deref "jolt.host" "form-vec-items") form))) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-map?") form)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted-map") (jolt-invoke (var-deref "jolt.host" "form-map-pairs") form)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-regex?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-regex " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "jolt.host" "form-regex-source") form)) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-inst?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-inst-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "jolt.host" "form-inst-source") form)) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-uuid?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-uuid-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "jolt.host" "form-uuid-source") form)) ")") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") form)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted-map-value") form) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-vector " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-quoted form)) ")") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "set?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-set " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-invoke (var-deref "clojure.core" "sort") (jolt-map emit-quoted form))) ")") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-list " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-quoted form)) ")") (if (jolt-truthy? (keyword #f "else")) (jolt-throw (let* ((_a$7739 (jolt-invoke (var-deref "clojure.core" "str") "emit-quoted: unsupported quoted form " (jolt-invoke (var-deref "clojure.core" "pr-str") form))) (_a$7740 (jolt-hash-map))) (jolt-ex-info _a$7739 _a$7740))) jolt-nil))))))))))))))))))) emit-quoted) (let* ((_o$7741 (keyword #f "private")) (_o$7742 #t)) (jolt-hash-map _o$7741 _o$7742)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-quoted" (letrec ((emit-quoted (lambda (form) (let fnrec7731 ((form form)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-char?") form)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") form) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-literal?") form)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") form) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") form)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") form)) (sns (jolt-invoke (var-deref "jolt.host" "form-sym-ns") form)) (nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") form))) (if (jolt-truthy? (let* ((and__25__auto m)) (if (jolt-truthy? and__25__auto) (jolt-pos? (jolt-count m)) and__25__auto))) (let* ((_a$7732 (var-deref "clojure.core" "str")) (_a$7733 "(jolt-symbol/meta ") (_a$7734 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$7735 " ") (_a$7736 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7737 " ") (_a$7738 (emit-quoted m)) (_a$7739 ")")) (jolt-invoke _a$7732 _a$7733 _a$7734 _a$7735 _a$7736 _a$7737 _a$7738 _a$7739)) (let* ((_a$7740 (var-deref "clojure.core" "str")) (_a$7741 "(jolt-symbol ") (_a$7742 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$7743 " ") (_a$7744 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7745 ")")) (jolt-invoke _a$7740 _a$7741 _a$7742 _a$7743 _a$7744 _a$7745)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-set?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-set " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-invoke (var-deref "clojure.core" "sort") (jolt-map emit-quoted (jolt-invoke (var-deref "jolt.host" "form-set-items") form)))) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-list " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-quoted (jolt-invoke (var-deref "jolt.host" "form-elements") form))) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-vec?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-vector " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-quoted (jolt-invoke (var-deref "jolt.host" "form-vec-items") form))) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-map?") form)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted-map") (jolt-invoke (var-deref "jolt.host" "form-map-pairs") form)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-regex?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-regex " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "jolt.host" "form-regex-source") form)) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-inst?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-inst-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "jolt.host" "form-inst-source") form)) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-uuid?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-uuid-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "jolt.host" "form-uuid-source") form)) ")") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") form)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted-map-value") form) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-vector " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-quoted form)) ")") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "set?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-set " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-invoke (var-deref "clojure.core" "sort") (jolt-map emit-quoted form))) ")") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-list " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-quoted form)) ")") (if (jolt-truthy? (keyword #f "else")) (jolt-throw (let* ((_a$7746 (jolt-invoke (var-deref "clojure.core" "str") "emit-quoted: unsupported quoted form " (jolt-invoke (var-deref "clojure.core" "pr-str") form))) (_a$7747 (jolt-hash-map))) (jolt-ex-info _a$7746 _a$7747))) jolt-nil))))))))))))))))))) emit-quoted) (let* ((_o$7748 (keyword #f "private")) (_o$7749 #t)) (jolt-hash-map _o$7748 _o$7749)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "jmeta-nonempty?" (letrec ((jmeta-nonempty? (lambda (m) (let fnrec7743 ((m m)) (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "map?") m))) (if (jolt-truthy? and__25__auto) (jolt-pos? (jolt-count m)) and__25__auto)))))) jmeta-nonempty?) (let* ((_o$7744 (keyword #f "private")) (_o$7745 #t)) (jolt-hash-map _o$7744 _o$7745)))) + (def-var-with-meta! "jolt.backend-scheme" "jmeta-nonempty?" (letrec ((jmeta-nonempty? (lambda (m) (let fnrec7750 ((m m)) (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "map?") m))) (if (jolt-truthy? and__25__auto) (jolt-pos? (jolt-count m)) and__25__auto)))))) jmeta-nonempty?) (let* ((_o$7751 (keyword #f "private")) (_o$7752 #t)) (jolt-hash-map _o$7751 _o$7752)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-def-meta" (letrec ((emit-def-meta (lambda (node) (let fnrec7746 ((node node)) (if (jolt-truthy? (jolt-get node (keyword #f "meta-expr"))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "meta-expr"))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get node (keyword #f "meta")))))))) emit-def-meta) (let* ((_o$7747 (keyword #f "private")) (_o$7748 #t)) (jolt-hash-map _o$7747 _o$7748)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-def-meta" (letrec ((emit-def-meta (lambda (node) (let fnrec7753 ((node node)) (if (jolt-truthy? (jolt-get node (keyword #f "meta-expr"))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "meta-expr"))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get node (keyword #f "meta")))))))) emit-def-meta) (let* ((_o$7754 (keyword #f "private")) (_o$7755 #t)) (jolt-hash-map _o$7754 _o$7755)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-binding" (letrec ((emit-binding (lambda (b) (let fnrec7749 ((b b)) (let* ((_a$7750 (var-deref "clojure.core" "str")) (_a$7751 "(") (_a$7752 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-nth b 0))) (_a$7753 " ") (_a$7754 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth b 1))) (_a$7755 ")")) (jolt-invoke _a$7750 _a$7751 _a$7752 _a$7753 _a$7754 _a$7755)))))) emit-binding) (let* ((_o$7756 (keyword #f "private")) (_o$7757 #t)) (jolt-hash-map _o$7756 _o$7757)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-binding" (letrec ((emit-binding (lambda (b) (let fnrec7756 ((b b)) (let* ((_a$7757 (var-deref "clojure.core" "str")) (_a$7758 "(") (_a$7759 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-nth b 0))) (_a$7760 " ") (_a$7761 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth b 1))) (_a$7762 ")")) (jolt-invoke _a$7757 _a$7758 _a$7759 _a$7760 _a$7761 _a$7762)))))) emit-binding) (let* ((_o$7763 (keyword #f "private")) (_o$7764 #t)) (jolt-hash-map _o$7763 _o$7764)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-let" (letrec ((emit-let (lambda (node) (let fnrec7758 ((node node)) (let* ((kw (if (jolt-truthy? (jolt-get node (keyword #f "letrec"))) "letrec*" "let*"))) (let* ((_a$7759 (var-deref "clojure.core" "str")) (_a$7760 "(") (_a$7761 kw) (_a$7762 " (") (_a$7763 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "emit-binding") (jolt-get node (keyword #f "bindings"))))) (_a$7764 ") ") (_a$7765 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$7766 ")")) (jolt-invoke _a$7759 _a$7760 _a$7761 _a$7762 _a$7763 _a$7764 _a$7765 _a$7766))))))) emit-let) (let* ((_o$7767 (keyword #f "private")) (_o$7768 #t)) (jolt-hash-map _o$7767 _o$7768)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-let" (letrec ((emit-let (lambda (node) (let fnrec7765 ((node node)) (let* ((kw (if (jolt-truthy? (jolt-get node (keyword #f "letrec"))) "letrec*" "let*"))) (let* ((_a$7766 (var-deref "clojure.core" "str")) (_a$7767 "(") (_a$7768 kw) (_a$7769 " (") (_a$7770 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "emit-binding") (jolt-get node (keyword #f "bindings"))))) (_a$7771 ") ") (_a$7772 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$7773 ")")) (jolt-invoke _a$7766 _a$7767 _a$7768 _a$7769 _a$7770 _a$7771 _a$7772 _a$7773))))))) emit-let) (let* ((_o$7774 (keyword #f "private")) (_o$7775 #t)) (jolt-hash-map _o$7774 _o$7775)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-loop" (letrec ((emit-loop (lambda (node) (let fnrec7769 ((node node)) (let* ((label (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "loop")) (pairs (jolt-get node (keyword #f "bindings"))) (names (jolt-map (lambda (p__95_) (let fnrec7770 ((p__95_ p__95_)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-nth p__95_ 0)))) pairs)) (inits (jolt-map (lambda (p__96_) (let fnrec7771 ((p__96_ p__96_)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth p__96_ 1)))) pairs)) (seq-bs (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (n i) (let fnrec7772 ((n n) (i i)) (jolt-invoke (var-deref "clojure.core" "str") "(" n " " i ")"))) names inits))) (rebinds (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (n) (let fnrec7773 ((n n)) (jolt-invoke (var-deref "clojure.core" "str") "(" n " " n ")"))) names))) (body (let* ((frame__20__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "jolt.backend-scheme" "*recur-target*") label))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__20__auto) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings")))))))) (jolt-invoke (var-deref "clojure.core" "str") "(let* (" seq-bs ") (let " label " (" rebinds ") " body "))")))))) emit-loop) (let* ((_o$7774 (keyword #f "private")) (_o$7775 #t)) (jolt-hash-map _o$7774 _o$7775)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-loop" (letrec ((emit-loop (lambda (node) (let fnrec7776 ((node node)) (let* ((label (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "loop")) (pairs (jolt-get node (keyword #f "bindings"))) (names (jolt-map (lambda (p__95_) (let fnrec7777 ((p__95_ p__95_)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-nth p__95_ 0)))) pairs)) (inits (jolt-map (lambda (p__96_) (let fnrec7778 ((p__96_ p__96_)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth p__96_ 1)))) pairs)) (seq-bs (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (n i) (let fnrec7779 ((n n) (i i)) (jolt-invoke (var-deref "clojure.core" "str") "(" n " " i ")"))) names inits))) (rebinds (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (n) (let fnrec7780 ((n n)) (jolt-invoke (var-deref "clojure.core" "str") "(" n " " n ")"))) names))) (body (let* ((frame__20__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "jolt.backend-scheme" "*recur-target*") label))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__20__auto) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings")))))))) (jolt-invoke (var-deref "clojure.core" "str") "(let* (" seq-bs ") (let " label " (" rebinds ") " body "))")))))) emit-loop) (let* ((_o$7781 (keyword #f "private")) (_o$7782 #t)) (jolt-hash-map _o$7781 _o$7782)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "ffi-types" (let* ((_o$7776 "int") (_o$7777 "int") (_o$7778 "uint") (_o$7779 "unsigned-int") (_o$7780 "long") (_o$7781 "long") (_o$7782 "ulong") (_o$7783 "unsigned-long") (_o$7784 "int64") (_o$7785 "integer-64") (_o$7786 "uint64") (_o$7787 "unsigned-64") (_o$7788 "size_t") (_o$7789 "size_t") (_o$7790 "ssize_t") (_o$7791 "ssize_t") (_o$7792 "iptr") (_o$7793 "iptr") (_o$7794 "uptr") (_o$7795 "uptr") (_o$7796 "double") (_o$7797 "double") (_o$7798 "float") (_o$7799 "float") (_o$7800 "pointer") (_o$7801 "void*") (_o$7802 "void*") (_o$7803 "void*") (_o$7804 "string") (_o$7805 "string") (_o$7806 "void") (_o$7807 "void") (_o$7808 "uint8") (_o$7809 "unsigned-8") (_o$7810 "u8") (_o$7811 "unsigned-8") (_o$7812 "byte") (_o$7813 "unsigned-8") (_o$7814 "char") (_o$7815 "char")) (jolt-hash-map _o$7776 _o$7777 _o$7778 _o$7779 _o$7780 _o$7781 _o$7782 _o$7783 _o$7784 _o$7785 _o$7786 _o$7787 _o$7788 _o$7789 _o$7790 _o$7791 _o$7792 _o$7793 _o$7794 _o$7795 _o$7796 _o$7797 _o$7798 _o$7799 _o$7800 _o$7801 _o$7802 _o$7803 _o$7804 _o$7805 _o$7806 _o$7807 _o$7808 _o$7809 _o$7810 _o$7811 _o$7812 _o$7813 _o$7814 _o$7815)) (let* ((_o$7816 (keyword #f "private")) (_o$7817 #t)) (jolt-hash-map _o$7816 _o$7817)))) + (def-var-with-meta! "jolt.backend-scheme" "ffi-types" (let* ((_o$7783 "int") (_o$7784 "int") (_o$7785 "uint") (_o$7786 "unsigned-int") (_o$7787 "long") (_o$7788 "long") (_o$7789 "ulong") (_o$7790 "unsigned-long") (_o$7791 "int64") (_o$7792 "integer-64") (_o$7793 "uint64") (_o$7794 "unsigned-64") (_o$7795 "size_t") (_o$7796 "size_t") (_o$7797 "ssize_t") (_o$7798 "ssize_t") (_o$7799 "iptr") (_o$7800 "iptr") (_o$7801 "uptr") (_o$7802 "uptr") (_o$7803 "double") (_o$7804 "double") (_o$7805 "float") (_o$7806 "float") (_o$7807 "pointer") (_o$7808 "void*") (_o$7809 "void*") (_o$7810 "void*") (_o$7811 "string") (_o$7812 "string") (_o$7813 "void") (_o$7814 "void") (_o$7815 "uint8") (_o$7816 "unsigned-8") (_o$7817 "u8") (_o$7818 "unsigned-8") (_o$7819 "byte") (_o$7820 "unsigned-8") (_o$7821 "char") (_o$7822 "char")) (jolt-hash-map _o$7783 _o$7784 _o$7785 _o$7786 _o$7787 _o$7788 _o$7789 _o$7790 _o$7791 _o$7792 _o$7793 _o$7794 _o$7795 _o$7796 _o$7797 _o$7798 _o$7799 _o$7800 _o$7801 _o$7802 _o$7803 _o$7804 _o$7805 _o$7806 _o$7807 _o$7808 _o$7809 _o$7810 _o$7811 _o$7812 _o$7813 _o$7814 _o$7815 _o$7816 _o$7817 _o$7818 _o$7819 _o$7820 _o$7821 _o$7822)) (let* ((_o$7823 (keyword #f "private")) (_o$7824 #t)) (jolt-hash-map _o$7823 _o$7824)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "ffi-type->chez" (letrec ((ffi-type->chez (lambda (t) (let fnrec7818 ((t t)) (let* ((or__26__auto (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-types") t))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-throw (let* ((_a$7819 (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi: unknown foreign type :" t)) (_a$7820 (jolt-hash-map))) (jolt-ex-info _a$7819 _a$7820))))))))) ffi-type->chez) (let* ((_o$7821 (keyword #f "private")) (_o$7822 #t)) (jolt-hash-map _o$7821 _o$7822)))) + (def-var-with-meta! "jolt.backend-scheme" "ffi-type->chez" (letrec ((ffi-type->chez (lambda (t) (let fnrec7825 ((t t)) (let* ((or__26__auto (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-types") t))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-throw (let* ((_a$7826 (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi: unknown foreign type :" t)) (_a$7827 (jolt-hash-map))) (jolt-ex-info _a$7826 _a$7827))))))))) ffi-type->chez) (let* ((_o$7828 (keyword #f "private")) (_o$7829 #t)) (jolt-hash-map _o$7828 _o$7829)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-ffi-fn" (letrec ((emit-ffi-fn (lambda (node) (let fnrec7823 ((node node)) (let* ((_a$7824 (var-deref "clojure.core" "str")) (_a$7825 "(foreign-procedure ") (_a$7826 (if (jolt-truthy? (jolt-get node (keyword #f "blocking"))) "__collect_safe " jolt-nil)) (_a$7827 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "csym")))) (_a$7828 " (") (_a$7829 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$7830 ") ") (_a$7831 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$7832 ")")) (jolt-invoke _a$7824 _a$7825 _a$7826 _a$7827 _a$7828 _a$7829 _a$7830 _a$7831 _a$7832)))))) emit-ffi-fn) (let* ((_o$7833 (keyword #f "private")) (_o$7834 #t)) (jolt-hash-map _o$7833 _o$7834)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-ffi-fn" (letrec ((emit-ffi-fn (lambda (node) (let fnrec7830 ((node node)) (let* ((_a$7831 (var-deref "clojure.core" "str")) (_a$7832 "(foreign-procedure ") (_a$7833 (if (jolt-truthy? (jolt-get node (keyword #f "blocking"))) "__collect_safe " jolt-nil)) (_a$7834 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "csym")))) (_a$7835 " (") (_a$7836 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$7837 ") ") (_a$7838 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$7839 ")")) (jolt-invoke _a$7831 _a$7832 _a$7833 _a$7834 _a$7835 _a$7836 _a$7837 _a$7838 _a$7839)))))) emit-ffi-fn) (let* ((_o$7840 (keyword #f "private")) (_o$7841 #t)) (jolt-hash-map _o$7840 _o$7841)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-ffi-callable" (letrec ((emit-ffi-callable (lambda (node) (let fnrec7835 ((node node)) (let* ((_a$7836 (var-deref "clojure.core" "str")) (_a$7837 "(jolt-ffi-register-callable! (foreign-callable ") (_a$7838 (if (jolt-truthy? (jolt-get node (keyword #f "collect-safe"))) "__collect_safe " jolt-nil)) (_a$7839 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "fn")))) (_a$7840 " (") (_a$7841 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$7842 ") ") (_a$7843 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$7844 "))")) (jolt-invoke _a$7836 _a$7837 _a$7838 _a$7839 _a$7840 _a$7841 _a$7842 _a$7843 _a$7844)))))) emit-ffi-callable) (let* ((_o$7845 (keyword #f "private")) (_o$7846 #t)) (jolt-hash-map _o$7845 _o$7846)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-ffi-callable" (letrec ((emit-ffi-callable (lambda (node) (let fnrec7842 ((node node)) (let* ((_a$7843 (var-deref "clojure.core" "str")) (_a$7844 "(jolt-ffi-register-callable! (foreign-callable ") (_a$7845 (if (jolt-truthy? (jolt-get node (keyword #f "collect-safe"))) "__collect_safe " jolt-nil)) (_a$7846 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "fn")))) (_a$7847 " (") (_a$7848 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$7849 ") ") (_a$7850 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$7851 "))")) (jolt-invoke _a$7843 _a$7844 _a$7845 _a$7846 _a$7847 _a$7848 _a$7849 _a$7850 _a$7851)))))) emit-ffi-callable) (let* ((_o$7852 (keyword #f "private")) (_o$7853 #t)) (jolt-hash-map _o$7852 _o$7853)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-recur" (letrec ((emit-recur (lambda (node) (let fnrec7847 ((node node)) (begin (if (jolt-not (var-deref "jolt.backend-scheme" "*recur-target*")) (jolt-throw (jolt-ex-info "emit: recur outside a loop/fn target" (jolt-hash-map))) jolt-nil) (let* ((arg-nodes (jolt-get node (keyword #f "args")))) (let* ((_a$7849 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7850 arg-nodes) (_a$7851 (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit") arg-nodes)) (_a$7852 (lambda (as) (let fnrec7848 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" (var-deref "jolt.backend-scheme" "*recur-target*") " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")"))))) (jolt-invoke _a$7849 _a$7850 _a$7851 _a$7852)))))))) emit-recur) (let* ((_o$7853 (keyword #f "private")) (_o$7854 #t)) (jolt-hash-map _o$7853 _o$7854)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-recur" (letrec ((emit-recur (lambda (node) (let fnrec7854 ((node node)) (begin (if (jolt-not (var-deref "jolt.backend-scheme" "*recur-target*")) (jolt-throw (jolt-ex-info "emit: recur outside a loop/fn target" (jolt-hash-map))) jolt-nil) (let* ((arg-nodes (jolt-get node (keyword #f "args")))) (let* ((_a$7856 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7857 arg-nodes) (_a$7858 (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit") arg-nodes)) (_a$7859 (lambda (as) (let fnrec7855 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" (var-deref "jolt.backend-scheme" "*recur-target*") " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")"))))) (jolt-invoke _a$7856 _a$7857 _a$7858 _a$7859)))))))) emit-recur) (let* ((_o$7860 (keyword #f "private")) (_o$7861 #t)) (jolt-hash-map _o$7860 _o$7861)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "nhint-init" (letrec ((nhint-init (lambda (nh orig munged) (let fnrec7855 ((nh nh) (orig orig) (munged munged)) (let* ((k (jolt-get nh orig))) (if (jolt= k (keyword #f "double")) (jolt-invoke (var-deref "clojure.core" "str") "(exact->inexact " munged ")") (if (jolt= k (keyword #f "long")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt->fx " munged ")") (if (jolt-truthy? (keyword #f "else")) munged jolt-nil)))))))) nhint-init) (let* ((_o$7856 (keyword #f "private")) (_o$7857 #t)) (jolt-hash-map _o$7856 _o$7857)))) + (def-var-with-meta! "jolt.backend-scheme" "nhint-init" (letrec ((nhint-init (lambda (nh orig munged) (let fnrec7862 ((nh nh) (orig orig) (munged munged)) (let* ((k (jolt-get nh orig))) (if (jolt= k (keyword #f "double")) (jolt-invoke (var-deref "clojure.core" "str") "(exact->inexact " munged ")") (if (jolt= k (keyword #f "long")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt->fx " munged ")") (if (jolt-truthy? (keyword #f "else")) munged jolt-nil)))))))) nhint-init) (let* ((_o$7863 (keyword #f "private")) (_o$7864 #t)) (jolt-hash-map _o$7863 _o$7864)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-arity-clause" (letrec ((emit-arity-clause (lambda (a) (let fnrec7858 ((a a)) (let* ((orig (jolt-get a (keyword #f "params"))) (nh (let* ((_a$7859 (jolt-hash-map)) (_a$7860 (jolt-get a (keyword #f "nhints")))) (jolt-into _a$7859 _a$7860))) (params (jolt-map (var-deref "jolt.backend-scheme" "munge-name") orig)) (restp (let* ((temp__27__auto (jolt-get a (keyword #f "rest")))) (if (jolt-truthy? temp__27__auto) (let* ((r temp__27__auto)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") r)) jolt-nil))) (label (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "fnrec")) (body (let* ((frame__20__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "jolt.backend-scheme" "*recur-target*") label))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__20__auto) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get a (keyword #f "body")))) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings"))))))) (paramlist (if (jolt-truthy? (let* ((and__25__auto restp)) (if (jolt-truthy? and__25__auto) (jolt-empty? params) and__25__auto))) restp (if (jolt-truthy? restp) (jolt-invoke (var-deref "clojure.core" "str") "(" (jolt-invoke (var-deref "clojure.string" "join") " " params) " . " restp ")") (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "str") "(" (jolt-invoke (var-deref "clojure.string" "join") " " params) ")") jolt-nil)))) (pbind (jolt-map (lambda (o p) (let fnrec7861 ((o o) (p p)) (jolt-invoke (var-deref "clojure.core" "str") "(" p " " (jolt-invoke (var-deref "jolt.backend-scheme" "nhint-init") nh o p) ")"))) orig params)) (binds (if (jolt-truthy? restp) (jolt-concat pbind (jolt-vector (jolt-invoke (var-deref "clojure.core" "str") "(" restp " (list->cseq " restp "))"))) pbind)) (lett (jolt-invoke (var-deref "clojure.core" "str") "(let " label " (" (jolt-invoke (var-deref "clojure.string" "join") " " binds) ") " body ")")) (ret (jolt-get a (keyword #f "ret-nhint")))) (let* ((_o$7862 paramlist) (_o$7863 (if (jolt= ret (keyword #f "double")) (jolt-invoke (var-deref "clojure.core" "str") "(exact->inexact " lett ")") (if (jolt= ret (keyword #f "long")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt->fx " lett ")") (if (jolt-truthy? (keyword #f "else")) lett jolt-nil))))) (jolt-vector _o$7862 _o$7863))))))) emit-arity-clause) (let* ((_o$7864 (keyword #f "private")) (_o$7865 #t)) (jolt-hash-map _o$7864 _o$7865)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-arity-clause" (letrec ((emit-arity-clause (lambda (a) (let fnrec7865 ((a a)) (let* ((orig (jolt-get a (keyword #f "params"))) (nh (let* ((_a$7866 (jolt-hash-map)) (_a$7867 (jolt-get a (keyword #f "nhints")))) (jolt-into _a$7866 _a$7867))) (params (jolt-map (var-deref "jolt.backend-scheme" "munge-name") orig)) (restp (let* ((temp__27__auto (jolt-get a (keyword #f "rest")))) (if (jolt-truthy? temp__27__auto) (let* ((r temp__27__auto)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") r)) jolt-nil))) (label (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "fnrec")) (body (let* ((frame__20__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "jolt.backend-scheme" "*recur-target*") label))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__20__auto) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get a (keyword #f "body")))) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings"))))))) (paramlist (if (jolt-truthy? (let* ((and__25__auto restp)) (if (jolt-truthy? and__25__auto) (jolt-empty? params) and__25__auto))) restp (if (jolt-truthy? restp) (jolt-invoke (var-deref "clojure.core" "str") "(" (jolt-invoke (var-deref "clojure.string" "join") " " params) " . " restp ")") (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "str") "(" (jolt-invoke (var-deref "clojure.string" "join") " " params) ")") jolt-nil)))) (pbind (jolt-map (lambda (o p) (let fnrec7868 ((o o) (p p)) (jolt-invoke (var-deref "clojure.core" "str") "(" p " " (jolt-invoke (var-deref "jolt.backend-scheme" "nhint-init") nh o p) ")"))) orig params)) (binds (if (jolt-truthy? restp) (jolt-concat pbind (jolt-vector (jolt-invoke (var-deref "clojure.core" "str") "(" restp " (list->cseq " restp "))"))) pbind)) (lett (jolt-invoke (var-deref "clojure.core" "str") "(let " label " (" (jolt-invoke (var-deref "clojure.string" "join") " " binds) ") " body ")")) (ret (jolt-get a (keyword #f "ret-nhint")))) (let* ((_o$7869 paramlist) (_o$7870 (if (jolt= ret (keyword #f "double")) (jolt-invoke (var-deref "clojure.core" "str") "(exact->inexact " lett ")") (if (jolt= ret (keyword #f "long")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt->fx " lett ")") (if (jolt-truthy? (keyword #f "else")) lett jolt-nil))))) (jolt-vector _o$7869 _o$7870))))))) emit-arity-clause) (let* ((_o$7871 (keyword #f "private")) (_o$7872 #t)) (jolt-hash-map _o$7871 _o$7872)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-fn" (letrec ((emit-fn (lambda (node) (let fnrec7866 ((node node)) (let* ((arities (jolt-get node (keyword #f "arities"))) (self (let* ((temp__27__auto (jolt-get node (keyword #f "name")))) (if (jolt-truthy? temp__27__auto) (let* ((nm temp__27__auto)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") nm)) jolt-nil))) (clauses (let* ((frame__20__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "jolt.backend-scheme" "*known-procs*") (if (jolt-truthy? self) (jolt-conj (var-deref "jolt.backend-scheme" "*known-procs*") self) (var-deref "jolt.backend-scheme" "*known-procs*"))))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__20__auto) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit-arity-clause") arities)) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings"))))))) (_lambda (if (jolt= 1 (jolt-count clauses)) (let* ((c (jolt-first clauses))) (let* ((_a$7867 (var-deref "clojure.core" "str")) (_a$7868 "(lambda ") (_a$7869 (jolt-nth c 0)) (_a$7870 " ") (_a$7871 (jolt-nth c 1)) (_a$7872 ")")) (jolt-invoke _a$7867 _a$7868 _a$7869 _a$7870 _a$7871 _a$7872))) (jolt-invoke (var-deref "clojure.core" "str") "(case-lambda " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (c) (let fnrec7873 ((c c)) (let* ((_a$7874 (var-deref "clojure.core" "str")) (_a$7875 "(") (_a$7876 (jolt-nth c 0)) (_a$7877 " ") (_a$7878 (jolt-nth c 1)) (_a$7879 ")")) (jolt-invoke _a$7874 _a$7875 _a$7876 _a$7877 _a$7878 _a$7879)))) clauses)) ")")))) (let* ((temp__16__auto (jolt-get node (keyword #f "name")))) (if (jolt-truthy? temp__16__auto) (let* ((nm temp__16__auto)) (let* ((m (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") nm))) (jolt-invoke (var-deref "clojure.core" "str") "(letrec ((" m " " _lambda ")) " m ")"))) _lambda))))))) emit-fn) (let* ((_o$7880 (keyword #f "private")) (_o$7881 #t)) (jolt-hash-map _o$7880 _o$7881)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-fn" (letrec ((emit-fn (lambda (node) (let fnrec7873 ((node node)) (let* ((arities (jolt-get node (keyword #f "arities"))) (self (let* ((temp__27__auto (jolt-get node (keyword #f "name")))) (if (jolt-truthy? temp__27__auto) (let* ((nm temp__27__auto)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") nm)) jolt-nil))) (clauses (let* ((frame__20__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "jolt.backend-scheme" "*known-procs*") (if (jolt-truthy? self) (jolt-conj (var-deref "jolt.backend-scheme" "*known-procs*") self) (var-deref "jolt.backend-scheme" "*known-procs*"))))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__20__auto) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit-arity-clause") arities)) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings"))))))) (_lambda (if (jolt= 1 (jolt-count clauses)) (let* ((c (jolt-first clauses))) (let* ((_a$7874 (var-deref "clojure.core" "str")) (_a$7875 "(lambda ") (_a$7876 (jolt-nth c 0)) (_a$7877 " ") (_a$7878 (jolt-nth c 1)) (_a$7879 ")")) (jolt-invoke _a$7874 _a$7875 _a$7876 _a$7877 _a$7878 _a$7879))) (jolt-invoke (var-deref "clojure.core" "str") "(case-lambda " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (c) (let fnrec7880 ((c c)) (let* ((_a$7881 (var-deref "clojure.core" "str")) (_a$7882 "(") (_a$7883 (jolt-nth c 0)) (_a$7884 " ") (_a$7885 (jolt-nth c 1)) (_a$7886 ")")) (jolt-invoke _a$7881 _a$7882 _a$7883 _a$7884 _a$7885 _a$7886)))) clauses)) ")")))) (let* ((temp__16__auto (jolt-get node (keyword #f "name")))) (if (jolt-truthy? temp__16__auto) (let* ((nm temp__16__auto)) (let* ((m (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") nm))) (jolt-invoke (var-deref "clojure.core" "str") "(letrec ((" m " " _lambda ")) " m ")"))) _lambda))))))) emit-fn) (let* ((_o$7887 (keyword #f "private")) (_o$7888 #t)) (jolt-hash-map _o$7887 _o$7888)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "native-op" (letrec ((native-op (lambda (fnode nargs) (let fnrec7882 ((fnode fnode) (nargs nargs)) (let* ((nm (let* ((G__140 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__140 (keyword #f "var")) (if (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) (jolt-get fnode (keyword #f "name")) jolt-nil) (if (jolt= G__140 (keyword #f "host")) (jolt-get fnode (keyword #f "name")) jolt-nil)))) (op (if (jolt-truthy? nm) (jolt-invoke (var-deref "jolt.backend-scheme" "native-ops") nm) jolt-nil)) (arity-ok (if (jolt-truthy? nm) (jolt-invoke (var-deref "jolt.backend-scheme" "op-arity") nm) jolt-nil))) (if (jolt-nil? op) jolt-nil (if (jolt-truthy? (let* ((and__25__auto arity-ok)) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke arity-ok nargs)) and__25__auto))) jolt-nil (if (jolt-truthy? (keyword #f "else")) op jolt-nil)))))))) native-op) (let* ((_o$7883 (keyword #f "private")) (_o$7884 #t)) (jolt-hash-map _o$7883 _o$7884)))) + (def-var-with-meta! "jolt.backend-scheme" "native-op" (letrec ((native-op (lambda (fnode nargs) (let fnrec7889 ((fnode fnode) (nargs nargs)) (let* ((nm (let* ((G__140 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__140 (keyword #f "var")) (if (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) (jolt-get fnode (keyword #f "name")) jolt-nil) (if (jolt= G__140 (keyword #f "host")) (jolt-get fnode (keyword #f "name")) jolt-nil)))) (op (if (jolt-truthy? nm) (jolt-invoke (var-deref "jolt.backend-scheme" "native-ops") nm) jolt-nil)) (arity-ok (if (jolt-truthy? nm) (jolt-invoke (var-deref "jolt.backend-scheme" "op-arity") nm) jolt-nil))) (if (jolt-nil? op) jolt-nil (if (jolt-truthy? (let* ((and__25__auto arity-ok)) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke arity-ok nargs)) and__25__auto))) jolt-nil (if (jolt-truthy? (keyword #f "else")) op jolt-nil)))))))) native-op) (let* ((_o$7890 (keyword #f "private")) (_o$7891 #t)) (jolt-hash-map _o$7890 _o$7891)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "ifn-kind" (letrec ((ifn-kind (lambda (fnode) (let fnrec7885 ((fnode fnode)) (let* ((G__141 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__141 (keyword #f "const")) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "keyword?") (jolt-get fnode (keyword #f "val")))) (keyword #f "keyword") jolt-nil) (if (let* ((or__26__auto (jolt= G__141 (keyword #f "map")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= G__141 (keyword #f "set")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= G__141 (keyword #f "vector")))))) (keyword #f "coll") jolt-nil))))))) ifn-kind) (let* ((_o$7886 (keyword #f "private")) (_o$7887 #t)) (jolt-hash-map _o$7886 _o$7887)))) + (def-var-with-meta! "jolt.backend-scheme" "ifn-kind" (letrec ((ifn-kind (lambda (fnode) (let fnrec7892 ((fnode fnode)) (let* ((G__141 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__141 (keyword #f "const")) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "keyword?") (jolt-get fnode (keyword #f "val")))) (keyword #f "keyword") jolt-nil) (if (let* ((or__26__auto (jolt= G__141 (keyword #f "map")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= G__141 (keyword #f "set")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= G__141 (keyword #f "vector")))))) (keyword #f "coll") jolt-nil))))))) ifn-kind) (let* ((_o$7893 (keyword #f "private")) (_o$7894 #t)) (jolt-hash-map _o$7893 _o$7894)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "stdlib-var?" (letrec ((stdlib-var? (lambda (n) (let fnrec7888 ((n n)) (let* ((and__25__auto (jolt= (keyword #f "var") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.string" "starts-with?") (let* ((or__26__auto (jolt-get n (keyword #f "ns")))) (if (jolt-truthy? or__26__auto) or__26__auto "")) "clojure.") and__25__auto)))))) stdlib-var?) (let* ((_o$7889 (keyword #f "private")) (_o$7890 #t)) (jolt-hash-map _o$7889 _o$7890)))) + (def-var-with-meta! "jolt.backend-scheme" "stdlib-var?" (letrec ((stdlib-var? (lambda (n) (let fnrec7895 ((n n)) (let* ((and__25__auto (jolt= (keyword #f "var") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.string" "starts-with?") (let* ((or__26__auto (jolt-get n (keyword #f "ns")))) (if (jolt-truthy? or__26__auto) or__26__auto "")) "clojure.") and__25__auto)))))) stdlib-var?) (let* ((_o$7896 (keyword #f "private")) (_o$7897 #t)) (jolt-hash-map _o$7896 _o$7897)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-numeric" (letrec ((emit-numeric (lambda (kind nm args order-args) (let fnrec7891 ((kind kind) (nm nm) (args args) (order-args order-args)) (if (let* ((and__25__auto (jolt= kind (keyword #f "double")))) (if (jolt-truthy? and__25__auto) (jolt= nm "inc") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(fl+ " (jolt-first args) " 1.0)") (if (let* ((and__25__auto (jolt= kind (keyword #f "double")))) (if (jolt-truthy? and__25__auto) (jolt= nm "dec") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(fl- " (jolt-first args) " 1.0)") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (jolt= nm "inc") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-l-inc " (jolt-first args) ")") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (jolt= nm "dec") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-l-dec " (jolt-first args) ")") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (jolt= nm "unchecked-inc") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-uncinc " (jolt-first args) ")") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (jolt= nm "unchecked-dec") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-uncdec " (jolt-first args) ")") (if (jolt-truthy? (keyword #f "else")) (let* ((op (let* ((G__142 kind)) (if (jolt= G__142 (keyword #f "double")) (jolt-invoke (var-deref "jolt.backend-scheme" "dbl-ops") nm) (if (jolt= G__142 (keyword #f "long")) (jolt-invoke (var-deref "jolt.backend-scheme" "lng-ops") nm) (if (jolt= G__142 (keyword #f "bigdec")) (jolt-invoke (var-deref "jolt.backend-scheme" "bd-ops") nm) (jolt-throw (let* ((_a$7892 (jolt-invoke (var-deref "clojure.core" "str") "No matching clause: " G__142)) (_a$7893 (jolt-hash-map))) (jolt-ex-info _a$7892 _a$7893))))))))) (jolt-invoke order-args (lambda (as) (let fnrec7894 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" op " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")"))))) jolt-nil))))))))))) emit-numeric) (let* ((_o$7895 (keyword #f "private")) (_o$7896 #t)) (jolt-hash-map _o$7895 _o$7896)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-numeric" (letrec ((emit-numeric (lambda (kind nm args order-args) (let fnrec7898 ((kind kind) (nm nm) (args args) (order-args order-args)) (if (let* ((and__25__auto (jolt= kind (keyword #f "double")))) (if (jolt-truthy? and__25__auto) (jolt= nm "inc") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(fl+ " (jolt-first args) " 1.0)") (if (let* ((and__25__auto (jolt= kind (keyword #f "double")))) (if (jolt-truthy? and__25__auto) (jolt= nm "dec") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(fl- " (jolt-first args) " 1.0)") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (jolt= nm "inc") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-l-inc " (jolt-first args) ")") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (jolt= nm "dec") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-l-dec " (jolt-first args) ")") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (jolt= nm "unchecked-inc") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-uncinc " (jolt-first args) ")") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (jolt= nm "unchecked-dec") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-uncdec " (jolt-first args) ")") (if (jolt-truthy? (keyword #f "else")) (let* ((op (let* ((G__142 kind)) (if (jolt= G__142 (keyword #f "double")) (jolt-invoke (var-deref "jolt.backend-scheme" "dbl-ops") nm) (if (jolt= G__142 (keyword #f "long")) (jolt-invoke (var-deref "jolt.backend-scheme" "lng-ops") nm) (if (jolt= G__142 (keyword #f "bigdec")) (jolt-invoke (var-deref "jolt.backend-scheme" "bd-ops") nm) (jolt-throw (let* ((_a$7899 (jolt-invoke (var-deref "clojure.core" "str") "No matching clause: " G__142)) (_a$7900 (jolt-hash-map))) (jolt-ex-info _a$7899 _a$7900))))))))) (jolt-invoke order-args (lambda (as) (let fnrec7901 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" op " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")"))))) jolt-nil))))))))))) emit-numeric) (let* ((_o$7902 (keyword #f "private")) (_o$7903 #t)) (jolt-hash-map _o$7902 _o$7903)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "struct-field-index" (letrec ((struct-field-index (lambda (shape kw) (let fnrec7897 ((shape shape) (kw kw)) (if (jolt-truthy? shape) (let* ((i 0)) (let loop7898 ((i i)) (if (>= i (jolt-count shape)) jolt-nil (if (jolt= (jolt-nth shape i) kw) i (if (jolt-truthy? (keyword #f "else")) (loop7898 (jolt-inc i)) jolt-nil))))) jolt-nil))))) struct-field-index) (let* ((_o$7899 (keyword #f "private")) (_o$7900 #t)) (jolt-hash-map _o$7899 _o$7900)))) + (def-var-with-meta! "jolt.backend-scheme" "struct-field-index" (letrec ((struct-field-index (lambda (shape kw) (let fnrec7904 ((shape shape) (kw kw)) (if (jolt-truthy? shape) (let* ((i 0)) (let loop7905 ((i i)) (if (>= i (jolt-count shape)) jolt-nil (if (jolt= (jolt-nth shape i) kw) i (if (jolt-truthy? (keyword #f "else")) (loop7905 (jolt-inc i)) jolt-nil))))) jolt-nil))))) struct-field-index) (let* ((_o$7906 (keyword #f "private")) (_o$7907 #t)) (jolt-hash-map _o$7906 _o$7907)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-invoke" (letrec ((emit-invoke (lambda (node) (let fnrec7901 ((node node)) (let* ((fnode (jolt-get node (keyword #f "fn"))) (arg-nodes (jolt-get node (keyword #f "args"))) (args (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit") arg-nodes)) (nop (jolt-invoke (var-deref "jolt.backend-scheme" "native-op") fnode (jolt-count args))) (kind (jolt-invoke (var-deref "jolt.backend-scheme" "ifn-kind") fnode)) (order-args (lambda (build) (let fnrec7902 ((build build)) (jolt-invoke (var-deref "jolt.backend-scheme" "ordered-call") arg-nodes args build)))) (defstr (lambda (as) (let fnrec7903 ((as as)) (if (> (jolt-count as) 1) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-nth as 1)) "")))) (invoke (lambda () (let fnrec7904 () (let* ((_a$7906 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7907 (jolt-cons fnode arg-nodes)) (_a$7908 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$7909 (lambda (G__143) (let fnrec7905 ((G__143 G__143)) (let* ((G__144 G__143) (f (jolt-nth G__144 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__144 1))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-invoke " f (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "") ")")))))) (jolt-invoke _a$7906 _a$7907 _a$7908 _a$7909)))))) (if (jolt-truthy? (jolt-get node (keyword #f "devirt-type"))) (jolt-invoke order-args (lambda (as) (let fnrec7910 ((as as)) (let* ((r (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_r$")) (dv (let* ((_a$7911 (var-deref "clojure.core" "str")) (_a$7912 "(devirt-resolve ") (_a$7913 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-type")))) (_a$7914 " ") (_a$7915 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-proto")))) (_a$7916 " ") (_a$7917 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-method")))) (_a$7918 " ") (_a$7919 r) (_a$7920 ")")) (jolt-invoke _a$7911 _a$7912 _a$7913 _a$7914 _a$7915 _a$7916 _a$7917 _a$7918 _a$7919 _a$7920))) (cells (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "devirt-cells"))) (resolver (if (jolt-truthy? cells) (let* ((c (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_dvc$"))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") cells jolt-conj c) (jolt-invoke (var-deref "clojure.core" "str") "(or " c " (let ((_f " dv ")) (set! " c " _f) _f))"))) dv))) (let* ((_a$7921 (var-deref "clojure.core" "str")) (_a$7922 "(let* ((") (_a$7923 r) (_a$7924 " ") (_a$7925 (jolt-first as)) (_a$7926 ")) (") (_a$7927 resolver) (_a$7928 " ") (_a$7929 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-cons r (jolt-rest as)))) (_a$7930 "))")) (jolt-invoke _a$7921 _a$7922 _a$7923 _a$7924 _a$7925 _a$7926 _a$7927 _a$7928 _a$7929 _a$7930)))))) (if (jolt-truthy? (jolt-get node (keyword #f "num-kind"))) (let* ((_a$7931 (var-deref "jolt.backend-scheme" "emit-numeric")) (_a$7932 (jolt-get node (keyword #f "num-kind"))) (_a$7933 (jolt-get fnode (keyword #f "name"))) (_a$7934 args) (_a$7935 order-args)) (jolt-invoke _a$7931 _a$7932 _a$7933 _a$7934 _a$7935)) (if (jolt-truthy? (let* ((and__25__auto nop)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-empty? args))) (if (jolt-truthy? and__25__auto) (jolt= nop "+") and__25__auto)) and__25__auto))) "0" (if (jolt-truthy? (let* ((and__25__auto nop)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-empty? args))) (if (jolt-truthy? and__25__auto) (jolt= nop "*") and__25__auto)) and__25__auto))) "1" (if (jolt-truthy? (let* ((and__25__auto nop)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= 1 (jolt-count args)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.backend-scheme" "cmp1-ops") nop) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "clojure.core" "str") "(begin " (jolt-first args) " #t)") (if (jolt-truthy? nop) (jolt-invoke order-args (lambda (as) (let fnrec7936 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" nop " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")")))) (if (jolt= kind (keyword #f "keyword")) (let* ((recv (jolt-first arg-nodes)) (idx (if (let* ((and__25__auto (jolt= (keyword #f "struct") (jolt-get recv (keyword #f "hint"))))) (if (jolt-truthy? and__25__auto) (jolt= 1 (jolt-count arg-nodes)) and__25__auto)) (let* ((_a$7937 (var-deref "jolt.backend-scheme" "struct-field-index")) (_a$7938 (jolt-get recv (keyword #f "shape"))) (_a$7939 (jolt-get fnode (keyword #f "val")))) (jolt-invoke _a$7937 _a$7938 _a$7939)) jolt-nil))) (if (jolt-truthy? idx) (jolt-invoke order-args (lambda (as) (let fnrec7940 ((as as)) (let* ((_a$7941 (var-deref "clojure.core" "str")) (_a$7942 "(jrec-field-at ") (_a$7943 (jolt-first as)) (_a$7944 " ") (_a$7945 idx) (_a$7946 " ") (_a$7947 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode)) (_a$7948 ")")) (jolt-invoke _a$7941 _a$7942 _a$7943 _a$7944 _a$7945 _a$7946 _a$7947 _a$7948))))) (jolt-invoke order-args (lambda (as) (let fnrec7949 ((as as)) (let* ((_a$7950 (var-deref "clojure.core" "str")) (_a$7951 "(jolt-get ") (_a$7952 (jolt-first as)) (_a$7953 " ") (_a$7954 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode)) (_a$7955 (jolt-invoke defstr as)) (_a$7956 ")")) (jolt-invoke _a$7950 _a$7951 _a$7952 _a$7953 _a$7954 _a$7955 _a$7956))))))) (if (jolt= kind (keyword #f "coll")) (let* ((_a$7958 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7959 (jolt-cons fnode arg-nodes)) (_a$7960 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$7961 (lambda (G__145) (let fnrec7957 ((G__145 G__145)) (let* ((G__146 G__145) (c (jolt-nth G__146 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__146 1))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-get " c " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")")))))) (jolt-invoke _a$7958 _a$7959 _a$7960 _a$7961)) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.backend-scheme" "stdlib-var?") fnode))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "prelude-mode?"))) and__25__auto))) (jolt-throw (let* ((_a$7968 (let* ((_a$7962 (var-deref "clojure.core" "str")) (_a$7963 "emit: unsupported stdlib fn `") (_a$7964 (jolt-get fnode (keyword #f "ns"))) (_a$7965 "/") (_a$7966 (jolt-get fnode (keyword #f "name"))) (_a$7967 "` (no core on Chez yet)")) (jolt-invoke _a$7962 _a$7963 _a$7964 _a$7965 _a$7966 _a$7967))) (_a$7969 (jolt-hash-map))) (jolt-ex-info _a$7968 _a$7969))) (if (jolt= (keyword #f "host-static") (jolt-get fnode (keyword #f "op"))) (jolt-invoke order-args (lambda (as) (let fnrec7970 ((as as)) (let* ((_a$7971 (var-deref "clojure.core" "str")) (_a$7972 "(host-static-call ") (_a$7973 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "class")))) (_a$7974 " ") (_a$7975 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "member")))) (_a$7976 (if (jolt-empty? as) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)))) (_a$7977 ")")) (jolt-invoke _a$7971 _a$7972 _a$7973 _a$7974 _a$7975 _a$7976 _a$7977))))) (if (jolt= (keyword #f "host") (jolt-get fnode (keyword #f "op"))) (jolt-throw (let* ((_a$7978 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host call `" (jolt-get fnode (keyword #f "name")) "`")) (_a$7979 (jolt-hash-map))) (jolt-ex-info _a$7978 _a$7979))) (if (jolt= (keyword #f "local") (jolt-get fnode (keyword #f "op"))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "*known-procs*") (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get fnode (keyword #f "name"))))) (jolt-invoke order-args (lambda (as) (let fnrec7980 ((as as)) (let* ((_a$7981 (var-deref "clojure.core" "str")) (_a$7982 "(") (_a$7983 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get fnode (keyword #f "name")))) (_a$7984 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$7985 ")")) (jolt-invoke _a$7981 _a$7982 _a$7983 _a$7984 _a$7985))))) (jolt-invoke invoke)) (if (jolt-truthy? (let* ((and__25__auto (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (let* ((_a$7986 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$7987 (jolt-get fnode (keyword #f "ns"))) (_a$7988 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7986 _a$7987 _a$7988)))) (if (jolt-truthy? and__25__auto) (let* ((_a$7989 (var-deref "jolt.backend-scheme" "direct-link-fn?")) (_a$7990 (jolt-get fnode (keyword #f "ns"))) (_a$7991 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7989 _a$7990 _a$7991)) and__25__auto)) and__25__auto))) (jolt-invoke order-args (lambda (as) (let fnrec7992 ((as as)) (let* ((_a$7996 (var-deref "clojure.core" "str")) (_a$7997 "(") (_a$7998 (let* ((_a$7993 (var-deref "jolt.backend-scheme" "dl-name")) (_a$7994 (jolt-get fnode (keyword #f "ns"))) (_a$7995 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7993 _a$7994 _a$7995))) (_a$7999 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$8000 ")")) (jolt-invoke _a$7996 _a$7997 _a$7998 _a$7999 _a$8000))))) (if (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))) (jolt-invoke invoke) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke invoke) jolt-nil)))))))))))))))))))) emit-invoke) (let* ((_o$8001 (keyword #f "private")) (_o$8002 #t)) (jolt-hash-map _o$8001 _o$8002)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-invoke" (letrec ((emit-invoke (lambda (node) (let fnrec7908 ((node node)) (let* ((fnode (jolt-get node (keyword #f "fn"))) (arg-nodes (jolt-get node (keyword #f "args"))) (args (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit") arg-nodes)) (nop (jolt-invoke (var-deref "jolt.backend-scheme" "native-op") fnode (jolt-count args))) (kind (jolt-invoke (var-deref "jolt.backend-scheme" "ifn-kind") fnode)) (order-args (lambda (build) (let fnrec7909 ((build build)) (jolt-invoke (var-deref "jolt.backend-scheme" "ordered-call") arg-nodes args build)))) (defstr (lambda (as) (let fnrec7910 ((as as)) (if (> (jolt-count as) 1) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-nth as 1)) "")))) (invoke (lambda () (let fnrec7911 () (let* ((_a$7913 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7914 (jolt-cons fnode arg-nodes)) (_a$7915 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$7916 (lambda (G__143) (let fnrec7912 ((G__143 G__143)) (let* ((G__144 G__143) (f (jolt-nth G__144 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__144 1))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-invoke " f (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "") ")")))))) (jolt-invoke _a$7913 _a$7914 _a$7915 _a$7916)))))) (if (jolt-truthy? (jolt-get node (keyword #f "devirt-type"))) (jolt-invoke order-args (lambda (as) (let fnrec7917 ((as as)) (let* ((r (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_r$")) (dv (let* ((_a$7918 (var-deref "clojure.core" "str")) (_a$7919 "(devirt-resolve ") (_a$7920 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-type")))) (_a$7921 " ") (_a$7922 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-proto")))) (_a$7923 " ") (_a$7924 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-method")))) (_a$7925 " ") (_a$7926 r) (_a$7927 ")")) (jolt-invoke _a$7918 _a$7919 _a$7920 _a$7921 _a$7922 _a$7923 _a$7924 _a$7925 _a$7926 _a$7927))) (cells (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "cache-cells"))) (resolver (if (jolt-truthy? cells) (let* ((c (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_dvc$"))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") cells jolt-conj c) (jolt-invoke (var-deref "clojure.core" "str") "(or " c " (let ((_f " dv ")) (set! " c " _f) _f))"))) dv))) (let* ((_a$7928 (var-deref "clojure.core" "str")) (_a$7929 "(let* ((") (_a$7930 r) (_a$7931 " ") (_a$7932 (jolt-first as)) (_a$7933 ")) (") (_a$7934 resolver) (_a$7935 " ") (_a$7936 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-cons r (jolt-rest as)))) (_a$7937 "))")) (jolt-invoke _a$7928 _a$7929 _a$7930 _a$7931 _a$7932 _a$7933 _a$7934 _a$7935 _a$7936 _a$7937)))))) (if (jolt-truthy? (jolt-get node (keyword #f "num-kind"))) (let* ((_a$7938 (var-deref "jolt.backend-scheme" "emit-numeric")) (_a$7939 (jolt-get node (keyword #f "num-kind"))) (_a$7940 (jolt-get fnode (keyword #f "name"))) (_a$7941 args) (_a$7942 order-args)) (jolt-invoke _a$7938 _a$7939 _a$7940 _a$7941 _a$7942)) (if (jolt-truthy? (let* ((and__25__auto nop)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-empty? args))) (if (jolt-truthy? and__25__auto) (jolt= nop "+") and__25__auto)) and__25__auto))) "0" (if (jolt-truthy? (let* ((and__25__auto nop)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-empty? args))) (if (jolt-truthy? and__25__auto) (jolt= nop "*") and__25__auto)) and__25__auto))) "1" (if (jolt-truthy? (let* ((and__25__auto nop)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= 1 (jolt-count args)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.backend-scheme" "cmp1-ops") nop) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "clojure.core" "str") "(begin " (jolt-first args) " #t)") (if (jolt-truthy? nop) (jolt-invoke order-args (lambda (as) (let fnrec7943 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" nop " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")")))) (if (jolt= kind (keyword #f "keyword")) (let* ((recv (jolt-first arg-nodes)) (idx (if (let* ((and__25__auto (jolt= (keyword #f "struct") (jolt-get recv (keyword #f "hint"))))) (if (jolt-truthy? and__25__auto) (jolt= 1 (jolt-count arg-nodes)) and__25__auto)) (let* ((_a$7944 (var-deref "jolt.backend-scheme" "struct-field-index")) (_a$7945 (jolt-get recv (keyword #f "shape"))) (_a$7946 (jolt-get fnode (keyword #f "val")))) (jolt-invoke _a$7944 _a$7945 _a$7946)) jolt-nil))) (if (jolt-truthy? idx) (jolt-invoke order-args (lambda (as) (let fnrec7947 ((as as)) (let* ((_a$7948 (var-deref "clojure.core" "str")) (_a$7949 "(jrec-field-at ") (_a$7950 (jolt-first as)) (_a$7951 " ") (_a$7952 idx) (_a$7953 " ") (_a$7954 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode)) (_a$7955 ")")) (jolt-invoke _a$7948 _a$7949 _a$7950 _a$7951 _a$7952 _a$7953 _a$7954 _a$7955))))) (jolt-invoke order-args (lambda (as) (let fnrec7956 ((as as)) (let* ((_a$7957 (var-deref "clojure.core" "str")) (_a$7958 "(jolt-get ") (_a$7959 (jolt-first as)) (_a$7960 " ") (_a$7961 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode)) (_a$7962 (jolt-invoke defstr as)) (_a$7963 ")")) (jolt-invoke _a$7957 _a$7958 _a$7959 _a$7960 _a$7961 _a$7962 _a$7963))))))) (if (jolt= kind (keyword #f "coll")) (let* ((_a$7965 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7966 (jolt-cons fnode arg-nodes)) (_a$7967 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$7968 (lambda (G__145) (let fnrec7964 ((G__145 G__145)) (let* ((G__146 G__145) (c (jolt-nth G__146 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__146 1))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-get " c " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")")))))) (jolt-invoke _a$7965 _a$7966 _a$7967 _a$7968)) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.backend-scheme" "stdlib-var?") fnode))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "prelude-mode?"))) and__25__auto))) (jolt-throw (let* ((_a$7975 (let* ((_a$7969 (var-deref "clojure.core" "str")) (_a$7970 "emit: unsupported stdlib fn `") (_a$7971 (jolt-get fnode (keyword #f "ns"))) (_a$7972 "/") (_a$7973 (jolt-get fnode (keyword #f "name"))) (_a$7974 "` (no core on Chez yet)")) (jolt-invoke _a$7969 _a$7970 _a$7971 _a$7972 _a$7973 _a$7974))) (_a$7976 (jolt-hash-map))) (jolt-ex-info _a$7975 _a$7976))) (if (jolt= (keyword #f "host-static") (jolt-get fnode (keyword #f "op"))) (jolt-invoke order-args (lambda (as) (let fnrec7977 ((as as)) (let* ((_a$7978 (var-deref "clojure.core" "str")) (_a$7979 "(host-static-call ") (_a$7980 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "class")))) (_a$7981 " ") (_a$7982 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "member")))) (_a$7983 (if (jolt-empty? as) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)))) (_a$7984 ")")) (jolt-invoke _a$7978 _a$7979 _a$7980 _a$7981 _a$7982 _a$7983 _a$7984))))) (if (jolt= (keyword #f "host") (jolt-get fnode (keyword #f "op"))) (jolt-throw (let* ((_a$7985 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host call `" (jolt-get fnode (keyword #f "name")) "`")) (_a$7986 (jolt-hash-map))) (jolt-ex-info _a$7985 _a$7986))) (if (jolt= (keyword #f "local") (jolt-get fnode (keyword #f "op"))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "*known-procs*") (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get fnode (keyword #f "name"))))) (jolt-invoke order-args (lambda (as) (let fnrec7987 ((as as)) (let* ((_a$7988 (var-deref "clojure.core" "str")) (_a$7989 "(") (_a$7990 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get fnode (keyword #f "name")))) (_a$7991 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$7992 ")")) (jolt-invoke _a$7988 _a$7989 _a$7990 _a$7991 _a$7992))))) (jolt-invoke invoke)) (if (jolt-truthy? (let* ((and__25__auto (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (let* ((_a$7993 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$7994 (jolt-get fnode (keyword #f "ns"))) (_a$7995 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7993 _a$7994 _a$7995)))) (if (jolt-truthy? and__25__auto) (let* ((_a$7996 (var-deref "jolt.backend-scheme" "direct-link-fn?")) (_a$7997 (jolt-get fnode (keyword #f "ns"))) (_a$7998 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7996 _a$7997 _a$7998)) and__25__auto)) and__25__auto))) (jolt-invoke order-args (lambda (as) (let fnrec7999 ((as as)) (let* ((_a$8003 (var-deref "clojure.core" "str")) (_a$8004 "(") (_a$8005 (let* ((_a$8000 (var-deref "jolt.backend-scheme" "dl-name")) (_a$8001 (jolt-get fnode (keyword #f "ns"))) (_a$8002 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$8000 _a$8001 _a$8002))) (_a$8006 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$8007 ")")) (jolt-invoke _a$8003 _a$8004 _a$8005 _a$8006 _a$8007))))) (if (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))) (jolt-invoke invoke) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke invoke) jolt-nil)))))))))))))))))))) emit-invoke) (let* ((_o$8008 (keyword #f "private")) (_o$8009 #t)) (jolt-hash-map _o$8008 _o$8009)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "emit-try" (letrec ((emit-try (lambda (node) (let fnrec8003 ((node node)) (let* ((core (let* ((temp__16__auto (jolt-get node (keyword #f "catch-sym")))) (if (jolt-truthy? temp__16__auto) (let* ((cs temp__16__auto)) (let* ((_a$8004 (var-deref "clojure.core" "str")) (_a$8005 "(guard (") (_a$8006 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") cs)) (_a$8007 " (else ") (_a$8008 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "catch-body")))) (_a$8009 ")) ") (_a$8010 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$8011 ")")) (jolt-invoke _a$8004 _a$8005 _a$8006 _a$8007 _a$8008 _a$8009 _a$8010 _a$8011))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body"))))))) (let* ((temp__16__auto (jolt-get node (keyword #f "finally")))) (if (jolt-truthy? temp__16__auto) (let* ((fin temp__16__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(dynamic-wind (lambda () #f) (lambda () " core ") (lambda () " (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fin) "))")) core))))))) emit-try) (let* ((_o$8012 (keyword #f "private")) (_o$8013 #t)) (jolt-hash-map _o$8012 _o$8013)))) + (def-var-with-meta! "jolt.backend-scheme" "emit-try" (letrec ((emit-try (lambda (node) (let fnrec8010 ((node node)) (let* ((core (let* ((temp__16__auto (jolt-get node (keyword #f "catch-sym")))) (if (jolt-truthy? temp__16__auto) (let* ((cs temp__16__auto)) (let* ((_a$8011 (var-deref "clojure.core" "str")) (_a$8012 "(guard (") (_a$8013 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") cs)) (_a$8014 " (else ") (_a$8015 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "catch-body")))) (_a$8016 ")) ") (_a$8017 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$8018 ")")) (jolt-invoke _a$8011 _a$8012 _a$8013 _a$8014 _a$8015 _a$8016 _a$8017 _a$8018))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body"))))))) (let* ((temp__16__auto (jolt-get node (keyword #f "finally")))) (if (jolt-truthy? temp__16__auto) (let* ((fin temp__16__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(dynamic-wind (lambda () #f) (lambda () " core ") (lambda () " (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fin) "))")) core))))))) emit-try) (let* ((_o$8019 (keyword #f "private")) (_o$8020 #t)) (jolt-hash-map _o$8019 _o$8020)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "returns-scheme-bool?" (letrec ((returns-scheme-bool? (case-lambda ((node) (let fnrec8014 ((node node)) (returns-scheme-bool? node (jolt-hash-set)))) ((node bools) (let fnrec8015 ((node node) (bools bools)) (if (jolt-truthy? (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get node (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "boolean?") (jolt-get node (keyword #f "val"))) and__25__auto))) #t (if (jolt= (keyword #f "invoke") (jolt-get node (keyword #f "op"))) (let* ((nop (let* ((_a$8016 (var-deref "jolt.backend-scheme" "native-op")) (_a$8017 (jolt-get node (keyword #f "fn"))) (_a$8018 (jolt-count (jolt-get node (keyword #f "args"))))) (jolt-invoke _a$8016 _a$8017 _a$8018)))) (jolt-invoke (var-deref "clojure.core" "boolean") (let* ((and__25__auto nop)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.backend-scheme" "bool-returning-ops") nop) and__25__auto)))) (if (jolt= (keyword #f "local") (jolt-get node (keyword #f "op"))) (jolt-contains? bools (jolt-get node (keyword #f "name"))) (if (jolt= (keyword #f "if") (jolt-get node (keyword #f "op"))) (let* ((and__25__auto (returns-scheme-bool? (jolt-get node (keyword #f "then")) bools))) (if (jolt-truthy? and__25__auto) (returns-scheme-bool? (jolt-get node (keyword #f "else")) bools) and__25__auto)) (if (jolt= (keyword #f "let") (jolt-get node (keyword #f "op"))) (let* ((bools_PRIME_ (let* ((_a$8020 (lambda (s b) (let fnrec8019 ((s s) (b b)) (if (jolt-truthy? (returns-scheme-bool? (jolt-nth b 1) s)) (jolt-conj s (jolt-nth b 0)) (jolt-invoke (var-deref "clojure.core" "disj") s (jolt-nth b 0)))))) (_a$8021 bools) (_a$8022 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$8020 _a$8021 _a$8022)))) (returns-scheme-bool? (jolt-get node (keyword #f "body")) bools_PRIME_)) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))))))))) returns-scheme-bool?) (let* ((_o$8023 (keyword #f "private")) (_o$8024 #t)) (jolt-hash-map _o$8023 _o$8024)))) + (def-var-with-meta! "jolt.backend-scheme" "returns-scheme-bool?" (letrec ((returns-scheme-bool? (case-lambda ((node) (let fnrec8021 ((node node)) (returns-scheme-bool? node (jolt-hash-set)))) ((node bools) (let fnrec8022 ((node node) (bools bools)) (if (jolt-truthy? (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get node (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "boolean?") (jolt-get node (keyword #f "val"))) and__25__auto))) #t (if (jolt= (keyword #f "invoke") (jolt-get node (keyword #f "op"))) (let* ((nop (let* ((_a$8023 (var-deref "jolt.backend-scheme" "native-op")) (_a$8024 (jolt-get node (keyword #f "fn"))) (_a$8025 (jolt-count (jolt-get node (keyword #f "args"))))) (jolt-invoke _a$8023 _a$8024 _a$8025)))) (jolt-invoke (var-deref "clojure.core" "boolean") (let* ((and__25__auto nop)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.backend-scheme" "bool-returning-ops") nop) and__25__auto)))) (if (jolt= (keyword #f "local") (jolt-get node (keyword #f "op"))) (jolt-contains? bools (jolt-get node (keyword #f "name"))) (if (jolt= (keyword #f "if") (jolt-get node (keyword #f "op"))) (let* ((and__25__auto (returns-scheme-bool? (jolt-get node (keyword #f "then")) bools))) (if (jolt-truthy? and__25__auto) (returns-scheme-bool? (jolt-get node (keyword #f "else")) bools) and__25__auto)) (if (jolt= (keyword #f "let") (jolt-get node (keyword #f "op"))) (let* ((bools_PRIME_ (let* ((_a$8027 (lambda (s b) (let fnrec8026 ((s s) (b b)) (if (jolt-truthy? (returns-scheme-bool? (jolt-nth b 1) s)) (jolt-conj s (jolt-nth b 0)) (jolt-invoke (var-deref "clojure.core" "disj") s (jolt-nth b 0)))))) (_a$8028 bools) (_a$8029 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$8027 _a$8028 _a$8029)))) (returns-scheme-bool? (jolt-get node (keyword #f "body")) bools_PRIME_)) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))))))))) returns-scheme-bool?) (let* ((_o$8030 (keyword #f "private")) (_o$8031 #t)) (jolt-hash-map _o$8030 _o$8031)))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit" (letrec ((emit (lambda (node) (let fnrec8025 ((node node)) (let* ((G__147 (jolt-get node (keyword #f "op")))) (if (jolt= G__147 (keyword #f "const")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") (jolt-get node (keyword #f "val"))) (if (jolt= G__147 (keyword #f "local")) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get node (keyword #f "name"))) (if (jolt= G__147 (keyword #f "var")) (let* ((core-proc (let* ((and__25__auto (jolt= "clojure.core" (jolt-get node (keyword #f "ns"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.backend-scheme" "core-value-procs") (jolt-get node (keyword #f "name"))) and__25__auto)))) (if (jolt-truthy? core-proc) core-proc (if (jolt-truthy? (let* ((_a$8026 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$8027 (jolt-get node (keyword #f "ns"))) (_a$8028 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$8026 _a$8027 _a$8028))) (let* ((_a$8029 (var-deref "jolt.backend-scheme" "dl-name")) (_a$8030 (jolt-get node (keyword #f "ns"))) (_a$8031 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$8029 _a$8030 _a$8031)) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.backend-scheme" "stdlib-var?") node))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "prelude-mode?"))) and__25__auto))) (jolt-throw (let* ((_a$8038 (let* ((_a$8032 (var-deref "clojure.core" "str")) (_a$8033 "emit: unsupported stdlib ref `") (_a$8034 (jolt-get node (keyword #f "ns"))) (_a$8035 "/") (_a$8036 (jolt-get node (keyword #f "name"))) (_a$8037 "` (no core on Chez yet)")) (jolt-invoke _a$8032 _a$8033 _a$8034 _a$8035 _a$8036 _a$8037))) (_a$8039 (jolt-hash-map))) (jolt-ex-info _a$8038 _a$8039))) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$8040 (var-deref "clojure.core" "str")) (_a$8041 "(var-deref ") (_a$8042 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8043 " ") (_a$8044 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8045 ")")) (jolt-invoke _a$8040 _a$8041 _a$8042 _a$8043 _a$8044 _a$8045)) jolt-nil))))) (if (jolt= G__147 (keyword #f "the-var")) (let* ((_a$8046 (var-deref "clojure.core" "str")) (_a$8047 "(jolt-var ") (_a$8048 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8049 " ") (_a$8050 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8051 ")")) (jolt-invoke _a$8046 _a$8047 _a$8048 _a$8049 _a$8050 _a$8051)) (if (jolt= G__147 (keyword #f "set-var")) (let* ((_a$8052 (var-deref "clojure.core" "str")) (_a$8053 "(jolt-var-set ") (_a$8054 (emit (jolt-get node (keyword #f "the-var")))) (_a$8055 " ") (_a$8056 (emit (jolt-get node (keyword #f "val")))) (_a$8057 ")")) (jolt-invoke _a$8052 _a$8053 _a$8054 _a$8055 _a$8056 _a$8057)) (if (jolt= G__147 (keyword #f "set-field")) (let* ((_a$8058 (var-deref "clojure.core" "str")) (_a$8059 "(jolt-set-field! ") (_a$8060 (emit (jolt-get node (keyword #f "obj")))) (_a$8061 " (keyword #f ") (_a$8062 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "field")))) (_a$8063 ") ") (_a$8064 (emit (jolt-get node (keyword #f "val")))) (_a$8065 ")")) (jolt-invoke _a$8058 _a$8059 _a$8060 _a$8061 _a$8062 _a$8063 _a$8064 _a$8065)) (if (jolt= G__147 (keyword #f "defmacro")) (let* ((_a$8066 (var-deref "clojure.core" "str")) (_a$8067 "(begin (def-var! ") (_a$8068 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8069 " ") (_a$8070 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8071 " ") (_a$8072 (emit (jolt-get node (keyword #f "fn")))) (_a$8073 ") (mark-macro! ") (_a$8074 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8075 " ") (_a$8076 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8077 ") jolt-nil)")) (jolt-invoke _a$8066 _a$8067 _a$8068 _a$8069 _a$8070 _a$8071 _a$8072 _a$8073 _a$8074 _a$8075 _a$8076 _a$8077)) (if (jolt= G__147 (keyword #f "host")) (jolt-throw (let* ((_a$8078 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host ref `" (jolt-get node (keyword #f "name")) "`")) (_a$8079 (jolt-hash-map))) (jolt-ex-info _a$8078 _a$8079))) (if (jolt= G__147 (keyword #f "host-static")) (let* ((_a$8080 (var-deref "clojure.core" "str")) (_a$8081 "(host-static-ref ") (_a$8082 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$8083 " ") (_a$8084 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "member")))) (_a$8085 ")")) (jolt-invoke _a$8080 _a$8081 _a$8082 _a$8083 _a$8084 _a$8085)) (if (jolt= G__147 (keyword #f "host-new")) (let* ((_a$8086 (var-deref "clojure.core" "str")) (_a$8087 "(host-new ") (_a$8088 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$8089 (let* ((args (jolt-map emit (jolt-get node (keyword #f "args"))))) (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args))))) (_a$8090 ")")) (jolt-invoke _a$8086 _a$8087 _a$8088 _a$8089 _a$8090)) (if (jolt= G__147 (keyword #f "if")) (let* ((test (jolt-get node (keyword #f "test"))) (t (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "returns-scheme-bool?") test)) (emit test) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-truthy? " (emit test) ")")))) (let* ((_a$8091 (var-deref "clojure.core" "str")) (_a$8092 "(if ") (_a$8093 t) (_a$8094 " ") (_a$8095 (emit (jolt-get node (keyword #f "then")))) (_a$8096 " ") (_a$8097 (emit (jolt-get node (keyword #f "else")))) (_a$8098 ")")) (jolt-invoke _a$8091 _a$8092 _a$8093 _a$8094 _a$8095 _a$8096 _a$8097 _a$8098))) (if (jolt= G__147 (keyword #f "do")) (let* ((_a$8099 (var-deref "clojure.core" "str")) (_a$8100 "(begin ") (_a$8101 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit (jolt-get node (keyword #f "statements"))))) (_a$8102 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$8103 (emit (jolt-get node (keyword #f "ret")))) (_a$8104 ")")) (jolt-invoke _a$8099 _a$8100 _a$8101 _a$8102 _a$8103 _a$8104)) (if (jolt= G__147 (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-invoke") node) (if (jolt= G__147 (keyword #f "vector")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-vector" (jolt-map emit (jolt-get node (keyword #f "items")))) (if (jolt= G__147 (keyword #f "set")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-hash-set" (jolt-map emit (jolt-get node (keyword #f "items")))) (if (jolt= G__147 (keyword #f "map")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-hash-map" (let* ((_a$8108 (var-deref "clojure.core" "mapcat")) (_a$8109 (lambda (p) (let fnrec8105 ((p p)) (let* ((_o$8106 (emit (jolt-nth p 0))) (_o$8107 (emit (jolt-nth p 1)))) (jolt-vector _o$8106 _o$8107))))) (_a$8110 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$8108 _a$8109 _a$8110))) (if (jolt= G__147 (keyword #f "quote")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get node (keyword #f "form"))) (if (jolt= G__147 (keyword #f "throw")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-throw " (emit (jolt-get node (keyword #f "expr"))) ")") (if (jolt= G__147 (keyword #f "coerce")) (let* ((e (emit (jolt-get node (keyword #f "expr"))))) (if (jolt= (keyword #f "double") (jolt-get node (keyword #f "kind"))) (jolt-invoke (var-deref "clojure.core" "str") "(exact->inexact " e ")") (if (jolt= (keyword #f "long") (jolt-get node (keyword #f "kind"))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt->fx " e ")") (if (jolt-truthy? (keyword #f "else")) e jolt-nil)))) (if (jolt= G__147 (keyword #f "try")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-try") node) (if (jolt= G__147 (keyword #f "regex")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-regex " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "source"))) ")") (if (jolt= G__147 (keyword #f "inst")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-inst-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "source"))) ")") (if (jolt= G__147 (keyword #f "uuid")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-uuid-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "source"))) ")") (if (jolt= G__147 (keyword #f "bigdec")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-bigdec-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "source"))) ")") (if (jolt= G__147 (keyword #f "the-ns")) (jolt-invoke (var-deref "clojure.core" "str") "(intern-ns! " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name"))) ")") (if (jolt= G__147 (keyword #f "host-call")) (let* ((m (jolt-get node (keyword #f "method"))) (target (emit (jolt-get node (keyword #f "target")))) (args (jolt-map emit (jolt-get node (keyword #f "args"))))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "supported-host-methods") m)) (let* ((_a$8111 (var-deref "clojure.core" "str")) (_a$8112 "(jolt-host-call ") (_a$8113 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$8114 " ") (_a$8115 target) (_a$8116 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$8117 ")")) (jolt-invoke _a$8111 _a$8112 _a$8113 _a$8114 _a$8115 _a$8116 _a$8117)) (let* ((_a$8118 (var-deref "clojure.core" "str")) (_a$8119 "(record-method-dispatch ") (_a$8120 target) (_a$8121 " ") (_a$8122 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$8123 " (jolt-vector") (_a$8124 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$8125 "))")) (jolt-invoke _a$8118 _a$8119 _a$8120 _a$8121 _a$8122 _a$8123 _a$8124 _a$8125)))) (if (jolt= G__147 (keyword #f "let")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-let") node) (if (jolt= G__147 (keyword #f "loop")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-loop") node) (if (jolt= G__147 (keyword #f "recur")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-recur") node) (if (jolt= G__147 (keyword #f "ffi-fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-fn") node) (if (jolt= G__147 (keyword #f "ffi-callable")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-callable") node) (if (jolt= G__147 (keyword #f "fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-fn") node) (if (jolt= G__147 (keyword #f "def")) (if (jolt-truthy? (jolt-get node (keyword #f "no-init"))) (let* ((_a$8126 (var-deref "clojure.core" "str")) (_a$8127 "(declare-var! ") (_a$8128 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8129 " ") (_a$8130 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8131 ")")) (jolt-invoke _a$8126 _a$8127 _a$8128 _a$8129 _a$8130 _a$8131)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$8132 (var-deref "clojure.core" "str")) (_a$8133 "(def-var-with-meta! ") (_a$8134 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8135 " ") (_a$8136 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8137 " ") (_a$8138 (emit (jolt-get node (keyword #f "init")))) (_a$8139 " ") (_a$8140 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$8141 ")")) (jolt-invoke _a$8132 _a$8133 _a$8134 _a$8135 _a$8136 _a$8137 _a$8138 _a$8139 _a$8140 _a$8141)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$8142 (var-deref "clojure.core" "str")) (_a$8143 "(def-var! ") (_a$8144 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8145 " ") (_a$8146 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8147 " ") (_a$8148 (emit (jolt-get node (keyword #f "init")))) (_a$8149 ")")) (jolt-invoke _a$8142 _a$8143 _a$8144 _a$8145 _a$8146 _a$8147 _a$8148 _a$8149)) jolt-nil))) (jolt-throw (let* ((_a$8150 (jolt-invoke (var-deref "clojure.core" "str") "emit: op not yet ported / unhandled: " (jolt-invoke (var-deref "clojure.core" "pr-str") (jolt-get node (keyword #f "op"))))) (_a$8151 (jolt-hash-map))) (jolt-ex-info _a$8150 _a$8151))))))))))))))))))))))))))))))))))))))))) emit))) + (def-var! "jolt.backend-scheme" "emit" (letrec ((emit (lambda (node) (let fnrec8032 ((node node)) (let* ((G__147 (jolt-get node (keyword #f "op")))) (if (jolt= G__147 (keyword #f "const")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") (jolt-get node (keyword #f "val"))) (if (jolt= G__147 (keyword #f "local")) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get node (keyword #f "name"))) (if (jolt= G__147 (keyword #f "var")) (let* ((core-proc (let* ((and__25__auto (jolt= "clojure.core" (jolt-get node (keyword #f "ns"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.backend-scheme" "core-value-procs") (jolt-get node (keyword #f "name"))) and__25__auto)))) (if (jolt-truthy? core-proc) core-proc (if (jolt-truthy? (let* ((_a$8033 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$8034 (jolt-get node (keyword #f "ns"))) (_a$8035 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$8033 _a$8034 _a$8035))) (let* ((_a$8036 (var-deref "jolt.backend-scheme" "dl-name")) (_a$8037 (jolt-get node (keyword #f "ns"))) (_a$8038 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$8036 _a$8037 _a$8038)) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.backend-scheme" "stdlib-var?") node))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "prelude-mode?"))) and__25__auto))) (jolt-throw (let* ((_a$8045 (let* ((_a$8039 (var-deref "clojure.core" "str")) (_a$8040 "emit: unsupported stdlib ref `") (_a$8041 (jolt-get node (keyword #f "ns"))) (_a$8042 "/") (_a$8043 (jolt-get node (keyword #f "name"))) (_a$8044 "` (no core on Chez yet)")) (jolt-invoke _a$8039 _a$8040 _a$8041 _a$8042 _a$8043 _a$8044))) (_a$8046 (jolt-hash-map))) (jolt-ex-info _a$8045 _a$8046))) (if (jolt-truthy? (keyword #f "else")) (let* ((cells (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "cache-cells"))) (nslit (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (nmlit (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name"))))) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "var-cache?")))) (if (jolt-truthy? and__25__auto) cells and__25__auto))) (let* ((c (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_vc$"))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") cells jolt-conj c) (jolt-invoke (var-deref "clojure.core" "str") "(var-cell-deref (or " c " (let ((_v (jolt-var " nslit " " nmlit "))) (set! " c " _v) _v)))"))) (jolt-invoke (var-deref "clojure.core" "str") "(var-deref " nslit " " nmlit ")"))) jolt-nil))))) (if (jolt= G__147 (keyword #f "the-var")) (let* ((_a$8047 (var-deref "clojure.core" "str")) (_a$8048 "(jolt-var ") (_a$8049 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8050 " ") (_a$8051 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8052 ")")) (jolt-invoke _a$8047 _a$8048 _a$8049 _a$8050 _a$8051 _a$8052)) (if (jolt= G__147 (keyword #f "set-var")) (let* ((_a$8053 (var-deref "clojure.core" "str")) (_a$8054 "(jolt-var-set ") (_a$8055 (emit (jolt-get node (keyword #f "the-var")))) (_a$8056 " ") (_a$8057 (emit (jolt-get node (keyword #f "val")))) (_a$8058 ")")) (jolt-invoke _a$8053 _a$8054 _a$8055 _a$8056 _a$8057 _a$8058)) (if (jolt= G__147 (keyword #f "set-field")) (let* ((_a$8059 (var-deref "clojure.core" "str")) (_a$8060 "(jolt-set-field! ") (_a$8061 (emit (jolt-get node (keyword #f "obj")))) (_a$8062 " (keyword #f ") (_a$8063 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "field")))) (_a$8064 ") ") (_a$8065 (emit (jolt-get node (keyword #f "val")))) (_a$8066 ")")) (jolt-invoke _a$8059 _a$8060 _a$8061 _a$8062 _a$8063 _a$8064 _a$8065 _a$8066)) (if (jolt= G__147 (keyword #f "defmacro")) (let* ((_a$8067 (var-deref "clojure.core" "str")) (_a$8068 "(begin (def-var! ") (_a$8069 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8070 " ") (_a$8071 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8072 " ") (_a$8073 (emit (jolt-get node (keyword #f "fn")))) (_a$8074 ") (mark-macro! ") (_a$8075 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8076 " ") (_a$8077 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8078 ") jolt-nil)")) (jolt-invoke _a$8067 _a$8068 _a$8069 _a$8070 _a$8071 _a$8072 _a$8073 _a$8074 _a$8075 _a$8076 _a$8077 _a$8078)) (if (jolt= G__147 (keyword #f "host")) (jolt-throw (let* ((_a$8079 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host ref `" (jolt-get node (keyword #f "name")) "`")) (_a$8080 (jolt-hash-map))) (jolt-ex-info _a$8079 _a$8080))) (if (jolt= G__147 (keyword #f "host-static")) (let* ((_a$8081 (var-deref "clojure.core" "str")) (_a$8082 "(host-static-ref ") (_a$8083 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$8084 " ") (_a$8085 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "member")))) (_a$8086 ")")) (jolt-invoke _a$8081 _a$8082 _a$8083 _a$8084 _a$8085 _a$8086)) (if (jolt= G__147 (keyword #f "host-new")) (let* ((_a$8087 (var-deref "clojure.core" "str")) (_a$8088 "(host-new ") (_a$8089 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$8090 (let* ((args (jolt-map emit (jolt-get node (keyword #f "args"))))) (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args))))) (_a$8091 ")")) (jolt-invoke _a$8087 _a$8088 _a$8089 _a$8090 _a$8091)) (if (jolt= G__147 (keyword #f "if")) (let* ((test (jolt-get node (keyword #f "test"))) (t (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "returns-scheme-bool?") test)) (emit test) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-truthy? " (emit test) ")")))) (let* ((_a$8092 (var-deref "clojure.core" "str")) (_a$8093 "(if ") (_a$8094 t) (_a$8095 " ") (_a$8096 (emit (jolt-get node (keyword #f "then")))) (_a$8097 " ") (_a$8098 (emit (jolt-get node (keyword #f "else")))) (_a$8099 ")")) (jolt-invoke _a$8092 _a$8093 _a$8094 _a$8095 _a$8096 _a$8097 _a$8098 _a$8099))) (if (jolt= G__147 (keyword #f "do")) (let* ((_a$8100 (var-deref "clojure.core" "str")) (_a$8101 "(begin ") (_a$8102 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit (jolt-get node (keyword #f "statements"))))) (_a$8103 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$8104 (emit (jolt-get node (keyword #f "ret")))) (_a$8105 ")")) (jolt-invoke _a$8100 _a$8101 _a$8102 _a$8103 _a$8104 _a$8105)) (if (jolt= G__147 (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-invoke") node) (if (jolt= G__147 (keyword #f "vector")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-vector" (jolt-map emit (jolt-get node (keyword #f "items")))) (if (jolt= G__147 (keyword #f "set")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-hash-set" (jolt-map emit (jolt-get node (keyword #f "items")))) (if (jolt= G__147 (keyword #f "map")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-hash-map" (let* ((_a$8109 (var-deref "clojure.core" "mapcat")) (_a$8110 (lambda (p) (let fnrec8106 ((p p)) (let* ((_o$8107 (emit (jolt-nth p 0))) (_o$8108 (emit (jolt-nth p 1)))) (jolt-vector _o$8107 _o$8108))))) (_a$8111 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$8109 _a$8110 _a$8111))) (if (jolt= G__147 (keyword #f "quote")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get node (keyword #f "form"))) (if (jolt= G__147 (keyword #f "throw")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-throw " (emit (jolt-get node (keyword #f "expr"))) ")") (if (jolt= G__147 (keyword #f "coerce")) (let* ((e (emit (jolt-get node (keyword #f "expr"))))) (if (jolt= (keyword #f "double") (jolt-get node (keyword #f "kind"))) (jolt-invoke (var-deref "clojure.core" "str") "(exact->inexact " e ")") (if (jolt= (keyword #f "long") (jolt-get node (keyword #f "kind"))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt->fx " e ")") (if (jolt-truthy? (keyword #f "else")) e jolt-nil)))) (if (jolt= G__147 (keyword #f "try")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-try") node) (if (jolt= G__147 (keyword #f "regex")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-regex " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "source"))) ")") (if (jolt= G__147 (keyword #f "inst")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-inst-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "source"))) ")") (if (jolt= G__147 (keyword #f "uuid")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-uuid-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "source"))) ")") (if (jolt= G__147 (keyword #f "bigdec")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-bigdec-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "source"))) ")") (if (jolt= G__147 (keyword #f "the-ns")) (jolt-invoke (var-deref "clojure.core" "str") "(intern-ns! " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name"))) ")") (if (jolt= G__147 (keyword #f "host-call")) (let* ((m (jolt-get node (keyword #f "method"))) (target (emit (jolt-get node (keyword #f "target")))) (args (jolt-map emit (jolt-get node (keyword #f "args"))))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "supported-host-methods") m)) (let* ((_a$8112 (var-deref "clojure.core" "str")) (_a$8113 "(jolt-host-call ") (_a$8114 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$8115 " ") (_a$8116 target) (_a$8117 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$8118 ")")) (jolt-invoke _a$8112 _a$8113 _a$8114 _a$8115 _a$8116 _a$8117 _a$8118)) (let* ((_a$8119 (var-deref "clojure.core" "str")) (_a$8120 "(record-method-dispatch ") (_a$8121 target) (_a$8122 " ") (_a$8123 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$8124 " (jolt-vector") (_a$8125 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$8126 "))")) (jolt-invoke _a$8119 _a$8120 _a$8121 _a$8122 _a$8123 _a$8124 _a$8125 _a$8126)))) (if (jolt= G__147 (keyword #f "let")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-let") node) (if (jolt= G__147 (keyword #f "loop")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-loop") node) (if (jolt= G__147 (keyword #f "recur")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-recur") node) (if (jolt= G__147 (keyword #f "ffi-fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-fn") node) (if (jolt= G__147 (keyword #f "ffi-callable")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-callable") node) (if (jolt= G__147 (keyword #f "fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-fn") node) (if (jolt= G__147 (keyword #f "def")) (if (jolt-truthy? (jolt-get node (keyword #f "no-init"))) (let* ((_a$8127 (var-deref "clojure.core" "str")) (_a$8128 "(declare-var! ") (_a$8129 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8130 " ") (_a$8131 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8132 ")")) (jolt-invoke _a$8127 _a$8128 _a$8129 _a$8130 _a$8131 _a$8132)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$8134 (var-deref "clojure.core" "str")) (_a$8135 "(def-var-with-meta! ") (_a$8136 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8137 " ") (_a$8138 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8139 " ") (_a$8140 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-with-cells") (lambda () (let fnrec8133 () (emit (jolt-get node (keyword #f "init"))))))) (_a$8141 " ") (_a$8142 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$8143 ")")) (jolt-invoke _a$8134 _a$8135 _a$8136 _a$8137 _a$8138 _a$8139 _a$8140 _a$8141 _a$8142 _a$8143)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$8145 (var-deref "clojure.core" "str")) (_a$8146 "(def-var! ") (_a$8147 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8148 " ") (_a$8149 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8150 " ") (_a$8151 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-with-cells") (lambda () (let fnrec8144 () (emit (jolt-get node (keyword #f "init"))))))) (_a$8152 ")")) (jolt-invoke _a$8145 _a$8146 _a$8147 _a$8148 _a$8149 _a$8150 _a$8151 _a$8152)) jolt-nil))) (jolt-throw (let* ((_a$8153 (jolt-invoke (var-deref "clojure.core" "str") "emit: op not yet ported / unhandled: " (jolt-invoke (var-deref "clojure.core" "pr-str") (jolt-get node (keyword #f "op"))))) (_a$8154 (jolt-hash-map))) (jolt-ex-info _a$8153 _a$8154))))))))))))))))))))))))))))))))))))))))) emit))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "dl-opt-out?" (letrec ((dl-opt-out? (lambda (m) (let fnrec8152 ((m m)) (let* ((or__26__auto (jolt-get m (keyword #f "dynamic")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-get m (keyword #f "redef")))))))) dl-opt-out?) (let* ((_o$8153 (keyword #f "private")) (_o$8154 #t)) (jolt-hash-map _o$8153 _o$8154)))) + (def-var-with-meta! "jolt.backend-scheme" "dl-opt-out?" (letrec ((dl-opt-out? (lambda (m) (let fnrec8155 ((m m)) (let* ((or__26__auto (jolt-get m (keyword #f "dynamic")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-get m (keyword #f "redef")))))))) dl-opt-out?) (let* ((_o$8156 (keyword #f "private")) (_o$8157 #t)) (jolt-hash-map _o$8156 _o$8157)))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit-top-form" (letrec ((emit-top-form (lambda (node) (let fnrec8155 ((node node)) (if (jolt-not (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link?"))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") node) (if (jolt= (keyword #f "do") (jolt-get node (keyword #f "op"))) (let* ((_a$8156 (var-deref "clojure.core" "str")) (_a$8157 "(begin ") (_a$8158 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-top-form (jolt-get node (keyword #f "statements"))))) (_a$8159 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$8160 (emit-top-form (jolt-get node (keyword #f "ret")))) (_a$8161 ")")) (jolt-invoke _a$8156 _a$8157 _a$8158 _a$8159 _a$8160 _a$8161)) (if (let* ((and__25__auto (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-get node (keyword #f "no-init"))))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "jolt.backend-scheme" "dl-opt-out?") (jolt-get node (keyword #f "meta")))) and__25__auto)) and__25__auto)) (let* ((ns (jolt-get node (keyword #f "ns"))) (nm (jolt-get node (keyword #f "name"))) (b (jolt-invoke (var-deref "jolt.backend-scheme" "dl-name") ns nm)) (fn? (jolt= (keyword #f "fn") (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "op")))) (pos (jolt-get node (keyword #f "pos"))) (frame-name (if (jolt-truthy? fn?) (let* ((temp__16__auto (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "name")))) (if (jolt-truthy? temp__16__auto) (let* ((fnm temp__16__auto)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") fnm)) b)) jolt-nil)) (reg (if (jolt-truthy? (let* ((and__25__auto fn?)) (if (jolt-truthy? and__25__auto) pos and__25__auto))) (let* ((_a$8162 (var-deref "clojure.core" "str")) (_a$8163 " (jolt-register-source! ") (_a$8164 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") frame-name)) (_a$8165 " ") (_a$8166 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$8167 " ") (_a$8168 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$8169 " ") (_a$8170 (if (jolt-truthy? (jolt-get pos (keyword #f "file"))) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get pos (keyword #f "file"))) "jolt-nil")) (_a$8171 " ") (_a$8172 (let* ((or__26__auto (jolt-get pos (keyword #f "line")))) (if (jolt-truthy? or__26__auto) or__26__auto 0))) (_a$8173 ")")) (jolt-invoke _a$8162 _a$8163 _a$8164 _a$8165 _a$8166 _a$8167 _a$8168 _a$8169 _a$8170 _a$8171 _a$8172 _a$8173)) jolt-nil))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.backend-scheme" "direct-link-defined") jolt-conj (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm)) (if (jolt-truthy? fn?) (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.backend-scheme" "direct-link-fns") jolt-conj (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm)) jolt-nil) (let* ((cells (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))) (_ (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "devirt-cells") cells)) (raw (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "init")))) (_ (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "devirt-cells") jolt-nil)) (init (if (jolt-truthy? (jolt-seq (jolt-invoke (var-deref "clojure.core" "deref") cells))) (jolt-invoke (var-deref "clojure.core" "str") "(let (" (jolt-invoke (var-deref "clojure.string" "join") " " (let* ((_a$8175 (lambda (c) (let fnrec8174 ((c c)) (jolt-invoke (var-deref "clojure.core" "str") "(" c " #f)")))) (_a$8176 (jolt-invoke (var-deref "clojure.core" "deref") cells))) (jolt-map _a$8175 _a$8176))) ") " raw ")") raw))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$8177 (var-deref "clojure.core" "str")) (_a$8178 "(begin (define ") (_a$8179 b) (_a$8180 " ") (_a$8181 init) (_a$8182 ") (def-var-with-meta! ") (_a$8183 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$8184 " ") (_a$8185 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$8186 " ") (_a$8187 b) (_a$8188 " ") (_a$8189 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$8190 ")") (_a$8191 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$8192 ")")) (jolt-invoke _a$8177 _a$8178 _a$8179 _a$8180 _a$8181 _a$8182 _a$8183 _a$8184 _a$8185 _a$8186 _a$8187 _a$8188 _a$8189 _a$8190 _a$8191 _a$8192)) (let* ((_a$8193 (var-deref "clojure.core" "str")) (_a$8194 "(begin (define ") (_a$8195 b) (_a$8196 " ") (_a$8197 init) (_a$8198 ") (def-var! ") (_a$8199 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$8200 " ") (_a$8201 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$8202 " ") (_a$8203 b) (_a$8204 ")") (_a$8205 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$8206 ")")) (jolt-invoke _a$8193 _a$8194 _a$8195 _a$8196 _a$8197 _a$8198 _a$8199 _a$8200 _a$8201 _a$8202 _a$8203 _a$8204 _a$8205 _a$8206)))))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") node) jolt-nil)))))))) emit-top-form))) + (def-var-with-meta! "jolt.backend-scheme" "emit-def-cached" (letrec ((emit-def-cached (lambda (node) (let fnrec8158 ((node node)) (let* ((ns (jolt-get node (keyword #f "ns"))) (nm (jolt-get node (keyword #f "name"))) (dl? (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link?")))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "jolt.backend-scheme" "dl-opt-out?") (jolt-get node (keyword #f "meta")))) and__25__auto))) (b (jolt-invoke (var-deref "jolt.backend-scheme" "dl-name") ns nm)) (fn? (jolt= (keyword #f "fn") (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "op")))) (pos (jolt-get node (keyword #f "pos"))) (frame-name (if (jolt-truthy? fn?) (let* ((temp__16__auto (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "name")))) (if (jolt-truthy? temp__16__auto) (let* ((fnm temp__16__auto)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") fnm)) b)) jolt-nil)) (reg (if (jolt-truthy? (let* ((and__25__auto dl?)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto fn?)) (if (jolt-truthy? and__25__auto) pos and__25__auto)) and__25__auto))) (let* ((_a$8159 (var-deref "clojure.core" "str")) (_a$8160 " (jolt-register-source! ") (_a$8161 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") frame-name)) (_a$8162 " ") (_a$8163 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$8164 " ") (_a$8165 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$8166 " ") (_a$8167 (if (jolt-truthy? (jolt-get pos (keyword #f "file"))) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get pos (keyword #f "file"))) "jolt-nil")) (_a$8168 " ") (_a$8169 (let* ((or__26__auto (jolt-get pos (keyword #f "line")))) (if (jolt-truthy? or__26__auto) or__26__auto 0))) (_a$8170 ")")) (jolt-invoke _a$8159 _a$8160 _a$8161 _a$8162 _a$8163 _a$8164 _a$8165 _a$8166 _a$8167 _a$8168 _a$8169 _a$8170)) jolt-nil)) (_ (if (jolt-truthy? dl?) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.backend-scheme" "direct-link-defined") jolt-conj (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm)) (if (jolt-truthy? fn?) (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.backend-scheme" "direct-link-fns") jolt-conj (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm)) jolt-nil)) jolt-nil)) (init (jolt-invoke (var-deref "jolt.backend-scheme" "emit-with-cells") (lambda () (let fnrec8171 () (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "init")))))))) (if (jolt-truthy? dl?) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$8172 (var-deref "clojure.core" "str")) (_a$8173 "(begin (define ") (_a$8174 b) (_a$8175 " ") (_a$8176 init) (_a$8177 ") (def-var-with-meta! ") (_a$8178 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$8179 " ") (_a$8180 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$8181 " ") (_a$8182 b) (_a$8183 " ") (_a$8184 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$8185 ")") (_a$8186 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$8187 ")")) (jolt-invoke _a$8172 _a$8173 _a$8174 _a$8175 _a$8176 _a$8177 _a$8178 _a$8179 _a$8180 _a$8181 _a$8182 _a$8183 _a$8184 _a$8185 _a$8186 _a$8187)) (let* ((_a$8188 (var-deref "clojure.core" "str")) (_a$8189 "(begin (define ") (_a$8190 b) (_a$8191 " ") (_a$8192 init) (_a$8193 ") (def-var! ") (_a$8194 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$8195 " ") (_a$8196 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$8197 " ") (_a$8198 b) (_a$8199 ")") (_a$8200 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$8201 ")")) (jolt-invoke _a$8188 _a$8189 _a$8190 _a$8191 _a$8192 _a$8193 _a$8194 _a$8195 _a$8196 _a$8197 _a$8198 _a$8199 _a$8200 _a$8201))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$8202 (var-deref "clojure.core" "str")) (_a$8203 "(def-var-with-meta! ") (_a$8204 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$8205 " ") (_a$8206 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$8207 " ") (_a$8208 init) (_a$8209 " ") (_a$8210 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$8211 ")")) (jolt-invoke _a$8202 _a$8203 _a$8204 _a$8205 _a$8206 _a$8207 _a$8208 _a$8209 _a$8210 _a$8211)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$8212 (var-deref "clojure.core" "str")) (_a$8213 "(def-var! ") (_a$8214 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$8215 " ") (_a$8216 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$8217 " ") (_a$8218 init) (_a$8219 ")")) (jolt-invoke _a$8212 _a$8213 _a$8214 _a$8215 _a$8216 _a$8217 _a$8218 _a$8219)) jolt-nil)))))))) emit-def-cached) (let* ((_o$8220 (keyword #f "private")) (_o$8221 #t)) (jolt-hash-map _o$8220 _o$8221)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.fold" "foldable" (let* ((_o$8207 "+") (_o$8208 jolt-add) (_o$8209 "-") (_o$8210 jolt-sub) (_o$8211 "*") (_o$8212 jolt-mul) (_o$8213 "/") (_o$8214 jolt-div) (_o$8215 "<") (_o$8216 <) (_o$8217 ">") (_o$8218 >) (_o$8219 "<=") (_o$8220 <=) (_o$8221 ">=") (_o$8222 >=) (_o$8223 "=") (_o$8224 jolt=) (_o$8225 "inc") (_o$8226 jolt-inc) (_o$8227 "dec") (_o$8228 jolt-dec) (_o$8229 "mod") (_o$8230 modulo) (_o$8231 "rem") (_o$8232 remainder) (_o$8233 "quot") (_o$8234 quotient) (_o$8235 "bit-and") (_o$8236 (var-deref "clojure.core" "__bit-and")) (_o$8237 "bit-or") (_o$8238 (var-deref "clojure.core" "__bit-or")) (_o$8239 "bit-xor") (_o$8240 (var-deref "clojure.core" "__bit-xor"))) (jolt-hash-map _o$8207 _o$8208 _o$8209 _o$8210 _o$8211 _o$8212 _o$8213 _o$8214 _o$8215 _o$8216 _o$8217 _o$8218 _o$8219 _o$8220 _o$8221 _o$8222 _o$8223 _o$8224 _o$8225 _o$8226 _o$8227 _o$8228 _o$8229 _o$8230 _o$8231 _o$8232 _o$8233 _o$8234 _o$8235 _o$8236 _o$8237 _o$8238 _o$8239 _o$8240)) (let* ((_o$8241 (keyword #f "private")) (_o$8242 #t)) (jolt-hash-map _o$8241 _o$8242)))) + (def-var! "jolt.backend-scheme" "emit-top-form" (letrec ((emit-top-form (lambda (node) (let fnrec8222 ((node node)) (if (jolt-not (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link?"))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") node) (if (jolt= (keyword #f "do") (jolt-get node (keyword #f "op"))) (let* ((_a$8223 (var-deref "clojure.core" "str")) (_a$8224 "(begin ") (_a$8225 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-top-form (jolt-get node (keyword #f "statements"))))) (_a$8226 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$8227 (emit-top-form (jolt-get node (keyword #f "ret")))) (_a$8228 ")")) (jolt-invoke _a$8223 _a$8224 _a$8225 _a$8226 _a$8227 _a$8228)) (if (let* ((and__25__auto (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-get node (keyword #f "no-init"))))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "jolt.backend-scheme" "dl-opt-out?") (jolt-get node (keyword #f "meta")))) and__25__auto)) and__25__auto)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-cached") node) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") node) jolt-nil)))))))) emit-top-form))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.fold" "const?" (letrec ((const? (lambda (n) (let fnrec8243 ((n n)) (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))))) const?) (let* ((_o$8244 (keyword #f "private")) (_o$8245 #t)) (jolt-hash-map _o$8244 _o$8245)))) + (def-var-with-meta! "jolt.passes.fold" "foldable" (let* ((_o$8229 "+") (_o$8230 jolt-add) (_o$8231 "-") (_o$8232 jolt-sub) (_o$8233 "*") (_o$8234 jolt-mul) (_o$8235 "/") (_o$8236 jolt-div) (_o$8237 "<") (_o$8238 <) (_o$8239 ">") (_o$8240 >) (_o$8241 "<=") (_o$8242 <=) (_o$8243 ">=") (_o$8244 >=) (_o$8245 "=") (_o$8246 jolt=) (_o$8247 "inc") (_o$8248 jolt-inc) (_o$8249 "dec") (_o$8250 jolt-dec) (_o$8251 "mod") (_o$8252 modulo) (_o$8253 "rem") (_o$8254 remainder) (_o$8255 "quot") (_o$8256 quotient) (_o$8257 "bit-and") (_o$8258 (var-deref "clojure.core" "__bit-and")) (_o$8259 "bit-or") (_o$8260 (var-deref "clojure.core" "__bit-or")) (_o$8261 "bit-xor") (_o$8262 (var-deref "clojure.core" "__bit-xor"))) (jolt-hash-map _o$8229 _o$8230 _o$8231 _o$8232 _o$8233 _o$8234 _o$8235 _o$8236 _o$8237 _o$8238 _o$8239 _o$8240 _o$8241 _o$8242 _o$8243 _o$8244 _o$8245 _o$8246 _o$8247 _o$8248 _o$8249 _o$8250 _o$8251 _o$8252 _o$8253 _o$8254 _o$8255 _o$8256 _o$8257 _o$8258 _o$8259 _o$8260 _o$8261 _o$8262)) (let* ((_o$8263 (keyword #f "private")) (_o$8264 #t)) (jolt-hash-map _o$8263 _o$8264)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.fold" "const-num?" (letrec ((const-num? (lambda (n) (let fnrec8246 ((n n)) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "const?") n))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "number?") (jolt-get n (keyword #f "val"))) and__25__auto)))))) const-num?) (let* ((_o$8247 (keyword #f "private")) (_o$8248 #t)) (jolt-hash-map _o$8247 _o$8248)))) + (def-var-with-meta! "jolt.passes.fold" "const?" (letrec ((const? (lambda (n) (let fnrec8265 ((n n)) (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))))) const?) (let* ((_o$8266 (keyword #f "private")) (_o$8267 #t)) (jolt-hash-map _o$8266 _o$8267)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.fold" "fold-fn" (letrec ((fold-fn (lambda (fnode) (let fnrec8249 ((fnode fnode)) (let* ((op (jolt-get fnode (keyword #f "op")))) (if (let* ((or__26__auto (let* ((and__25__auto (jolt= op (keyword #f "var")))) (if (jolt-truthy? and__25__auto) (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) and__25__auto)))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= op (keyword #f "host")))) (jolt-get (var-deref "jolt.passes.fold" "foldable") (jolt-get fnode (keyword #f "name"))) jolt-nil)))))) fold-fn) (let* ((_o$8250 (keyword #f "private")) (_o$8251 #t)) (jolt-hash-map _o$8250 _o$8251)))) + (def-var-with-meta! "jolt.passes.fold" "const-num?" (letrec ((const-num? (lambda (n) (let fnrec8268 ((n n)) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "const?") n))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "number?") (jolt-get n (keyword #f "val"))) and__25__auto)))))) const-num?) (let* ((_o$8269 (keyword #f "private")) (_o$8270 #t)) (jolt-hash-map _o$8269 _o$8270)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.fold" "const-fold" (letrec ((const-fold (lambda (node) (let fnrec8252 ((node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "invoke")) (let* ((n (jolt-invoke (var-deref "jolt.ir" "map-ir-children") const-fold node)) (ff (jolt-invoke (var-deref "jolt.passes.fold" "fold-fn") (jolt-get n (keyword #f "fn")))) (args (jolt-get n (keyword #f "args"))) (folded (if (jolt-truthy? (let* ((and__25__auto ff)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-pos? (jolt-count args)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "every?") (var-deref "jolt.passes.fold" "const-num?") args) and__25__auto)) and__25__auto))) (guard (_r$catch1577 (else (let* ((e _r$catch1577)) jolt-nil))) (let* ((_o$8254 (keyword #f "op")) (_o$8255 (keyword #f "const")) (_o$8256 (keyword #f "val")) (_o$8257 (jolt-apply ff (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (a) (let fnrec8253 ((a a)) (jolt-get a (keyword #f "val")))) args)))) (jolt-hash-map _o$8254 _o$8255 _o$8256 _o$8257))) jolt-nil))) (let* ((or__26__auto folded)) (if (jolt-truthy? or__26__auto) or__26__auto n))) (if (jolt= op (keyword #f "if")) (let* ((t (const-fold (jolt-get node (keyword #f "test"))))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.fold" "const?") t)) (if (let* ((or__26__auto (jolt-nil? (jolt-get t (keyword #f "val"))))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= #f (jolt-get t (keyword #f "val"))))) (const-fold (jolt-get node (keyword #f "else"))) (const-fold (jolt-get node (keyword #f "then")))) (let* ((_a$8258 node) (_a$8259 (keyword #f "test")) (_a$8260 t) (_a$8261 (keyword #f "then")) (_a$8262 (const-fold (jolt-get node (keyword #f "then")))) (_a$8263 (keyword #f "else")) (_a$8264 (const-fold (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$8258 _a$8259 _a$8260 _a$8261 _a$8262 _a$8263 _a$8264)))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") const-fold node) jolt-nil)))))))) const-fold) (let* ((_o$8265 (keyword #f "doc")) (_o$8266 "Bottom-up constant folding: a call of a foldable numeric fn whose args are\n all constant numbers becomes a constant; an if with a constant test becomes\n the taken branch.")) (jolt-hash-map _o$8265 _o$8266)))) + (def-var-with-meta! "jolt.passes.fold" "fold-fn" (letrec ((fold-fn (lambda (fnode) (let fnrec8271 ((fnode fnode)) (let* ((op (jolt-get fnode (keyword #f "op")))) (if (let* ((or__26__auto (let* ((and__25__auto (jolt= op (keyword #f "var")))) (if (jolt-truthy? and__25__auto) (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) and__25__auto)))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= op (keyword #f "host")))) (jolt-get (var-deref "jolt.passes.fold" "foldable") (jolt-get fnode (keyword #f "name"))) jolt-nil)))))) fold-fn) (let* ((_o$8272 (keyword #f "private")) (_o$8273 #t)) (jolt-hash-map _o$8272 _o$8273)))) (guard (e (#t #f)) - (def-var! "jolt.passes.fold" "scalar-const?" (letrec ((scalar-const? (lambda (n) (let fnrec8267 ((n n)) (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((v (jolt-get n (keyword #f "val")))) (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "keyword?") v))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "string?") v))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "number?") v))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-invoke (var-deref "clojure.core" "boolean?") v)))))))) and__25__auto)))))) scalar-const?))) + (def-var-with-meta! "jolt.passes.fold" "const-fold" (letrec ((const-fold (lambda (node) (let fnrec8274 ((node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "invoke")) (let* ((n (jolt-invoke (var-deref "jolt.ir" "map-ir-children") const-fold node)) (ff (jolt-invoke (var-deref "jolt.passes.fold" "fold-fn") (jolt-get n (keyword #f "fn")))) (args (jolt-get n (keyword #f "args"))) (folded (if (jolt-truthy? (let* ((and__25__auto ff)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-pos? (jolt-count args)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "every?") (var-deref "jolt.passes.fold" "const-num?") args) and__25__auto)) and__25__auto))) (guard (_r$catch1583 (else (let* ((e _r$catch1583)) jolt-nil))) (let* ((_o$8276 (keyword #f "op")) (_o$8277 (keyword #f "const")) (_o$8278 (keyword #f "val")) (_o$8279 (jolt-apply ff (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (a) (let fnrec8275 ((a a)) (jolt-get a (keyword #f "val")))) args)))) (jolt-hash-map _o$8276 _o$8277 _o$8278 _o$8279))) jolt-nil))) (let* ((or__26__auto folded)) (if (jolt-truthy? or__26__auto) or__26__auto n))) (if (jolt= op (keyword #f "if")) (let* ((t (const-fold (jolt-get node (keyword #f "test"))))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.fold" "const?") t)) (if (let* ((or__26__auto (jolt-nil? (jolt-get t (keyword #f "val"))))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= #f (jolt-get t (keyword #f "val"))))) (const-fold (jolt-get node (keyword #f "else"))) (const-fold (jolt-get node (keyword #f "then")))) (let* ((_a$8280 node) (_a$8281 (keyword #f "test")) (_a$8282 t) (_a$8283 (keyword #f "then")) (_a$8284 (const-fold (jolt-get node (keyword #f "then")))) (_a$8285 (keyword #f "else")) (_a$8286 (const-fold (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$8280 _a$8281 _a$8282 _a$8283 _a$8284 _a$8285 _a$8286)))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") const-fold node) jolt-nil)))))))) const-fold) (let* ((_o$8287 (keyword #f "doc")) (_o$8288 "Bottom-up constant folding: a call of a foldable numeric fn whose args are\n all constant numbers becomes a constant; an if with a constant test becomes\n the taken branch.")) (jolt-hash-map _o$8287 _o$8288)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.fold" "kw-callee?" (letrec ((kw-callee? (lambda (fnode) (let fnrec8268 ((fnode fnode)) (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "keyword?") (jolt-get fnode (keyword #f "val"))) and__25__auto)))))) kw-callee?) (let* ((_o$8269 (keyword #f "doc")) (_o$8270 "True if fnode is a constant keyword used as a function head \x2014; the (:k m) form.")) (jolt-hash-map _o$8269 _o$8270)))) + (def-var! "jolt.passes.fold" "scalar-const?" (letrec ((scalar-const? (lambda (n) (let fnrec8289 ((n n)) (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((v (jolt-get n (keyword #f "val")))) (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "keyword?") v))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "string?") v))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "number?") v))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-invoke (var-deref "clojure.core" "boolean?") v)))))))) and__25__auto)))))) scalar-const?))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.fold" "get-callee?" (letrec ((get-callee? (lambda (fnode) (let fnrec8271 ((fnode fnode)) (let* ((or__26__auto (let* ((and__25__auto (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))))) (if (jolt-truthy? and__25__auto) (jolt= "get" (jolt-get fnode (keyword #f "name"))) and__25__auto)) and__25__auto)))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((and__25__auto (jolt= (keyword #f "host") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt= "get" (jolt-get fnode (keyword #f "name"))) and__25__auto)))))))) get-callee?) (let* ((_o$8272 (keyword #f "doc")) (_o$8273 "True if fnode is the clojure.core/get (or host get) callee \x2014; the (get m k) form.")) (jolt-hash-map _o$8272 _o$8273)))) + (def-var-with-meta! "jolt.passes.fold" "kw-callee?" (letrec ((kw-callee? (lambda (fnode) (let fnrec8290 ((fnode fnode)) (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "keyword?") (jolt-get fnode (keyword #f "val"))) and__25__auto)))))) kw-callee?) (let* ((_o$8291 (keyword #f "doc")) (_o$8292 "True if fnode is a constant keyword used as a function head \x2014; the (:k m) form.")) (jolt-hash-map _o$8291 _o$8292)))) +(guard (e (#t #f)) + (def-var-with-meta! "jolt.passes.fold" "get-callee?" (letrec ((get-callee? (lambda (fnode) (let fnrec8293 ((fnode fnode)) (let* ((or__26__auto (let* ((and__25__auto (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))))) (if (jolt-truthy? and__25__auto) (jolt= "get" (jolt-get fnode (keyword #f "name"))) and__25__auto)) and__25__auto)))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((and__25__auto (jolt= (keyword #f "host") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt= "get" (jolt-get fnode (keyword #f "name"))) and__25__auto)))))))) get-callee?) (let* ((_o$8294 (keyword #f "doc")) (_o$8295 "True if fnode is the clojure.core/get (or host get) callee \x2014; the (get m k) form.")) (jolt-hash-map _o$8294 _o$8295)))) (guard (e (#t #f)) (def-var-with-meta! "jolt.passes.numeric" "int-lit?" (letrec ((int-lit? (lambda (n) (let fnrec6602 ((n n)) (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((v (jolt-get n (keyword #f "val")))) (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "number?") v))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "integer?") v) and__25__auto))) and__25__auto)))))) int-lit?) (let* ((_o$6603 (keyword #f "private")) (_o$6604 #t)) (jolt-hash-map _o$6603 _o$6604)))) (guard (e (#t #f)) diff --git a/jolt-core/jolt/backend_scheme.clj b/jolt-core/jolt/backend_scheme.clj index 7fa62a8..0300884 100644 --- a/jolt-core/jolt/backend_scheme.clj +++ b/jolt-core/jolt/backend_scheme.clj @@ -160,6 +160,14 @@ (def direct-link-fns (atom #{})) (defn direct-link-reset! [] (reset! direct-link-defined #{}) (reset! direct-link-fns #{})) +;; Cache a resolved var cell in a per-site cell so a non-direct-linked var +;; reference skips the name lookup (string-append + hash) after the first use. +;; OFF during the seed mint (the seed must stay a byte-fixpoint, and caching the +;; compiler's own refs shifts the gensym-numbered cell names every pass); the +;; runtime eval path turns it on for user code, where it's the big win. +(def var-cache? (atom false)) +(defn set-var-cache! [on] (reset! var-cache? on)) + ;; A direct-link Scheme binding name for a var. The fqn maps to a unique identifier ;; jv$$; chars that break a Scheme identifier or the `$` separator are ;; escaped so distinct vars never collide. @@ -183,14 +191,29 @@ (def ^:private gensym-counter (atom 0)) (defn- fresh-label [prefix] (str prefix (swap! gensym-counter inc))) -;; Per-site devirt cache cells collected while emitting one top-level def. A -;; devirtualized call resolves a CONSTANT impl (static tag/proto/method), so it -;; needs resolving once, not per call — the inline cache the JVM gets for free. When -;; a def init is being emitted this holds an atom; each devirt site appends a fresh -;; cell name (bound to #f in a let wrapping the def, so it persists across calls and -;; is shared by every invocation), and the site resolves into it on first use. nil -;; outside a def (a devirt there falls back to a per-call resolve). -(def ^:private devirt-cells (atom nil)) +;; Per-site cache cells collected while emitting one top-level def. A site that +;; resolves a STABLE value — a devirtualized impl (constant tag/proto/method) or a +;; var cell (interned, so the cell never changes even when the var is redefined) — +;; resolves it once, not per call, the inline cache the JVM gets for free. When a +;; def init is being emitted this holds an atom; each site appends a fresh cell name +;; (bound to #f in a let wrapping the def, so it persists across calls and is shared +;; by every invocation) and resolves into it on first use. nil outside a def (a site +;; there falls back to a per-call resolve). +(def ^:private cache-cells (atom nil)) + +;; Emit a def's init (via the supplied thunk) under a fresh cache-cell collector, +;; then wrap the result in a let binding any cells its body registered so they +;; persist in the def's closure. Saves/restores the outer collector for nested +;; defs. Used by both the runtime def emit and the direct-link top-level emit. +(defn- emit-with-cells [emit-thunk] + (let [cells (atom []) + prev @cache-cells + _ (reset! cache-cells cells) + raw (emit-thunk) + _ (reset! cache-cells prev)] + (if (seq @cells) + (str "(let (" (str/join " " (map (fn [c] (str "(" c " #f)")) @cells)) ") " raw ")") + raw))) ;; Scheme syntactic keywords. A jolt local with one of these names would, when ;; emitted verbatim, shadow the Scheme form in operator position (a local named @@ -569,7 +592,7 @@ dv (str "(devirt-resolve " (chez-str-lit (:devirt-type node)) " " (chez-str-lit (:devirt-proto node)) " " (chez-str-lit (:devirt-method node)) " " r ")") - cells @devirt-cells + cells @cache-cells ;; cache the resolved impl in a per-site cell when inside a ;; def (resolved once on first call, then reused); else ;; resolve per call. @@ -699,7 +722,22 @@ (and (stdlib-var? node) (not (deref prelude-mode?))) (throw (ex-info (str "emit: unsupported stdlib ref `" (:ns node) "/" (:name node) "` (no core on Chez yet)") {})) - :else (str "(var-deref " (chez-str-lit (:ns node)) " " (chez-str-lit (:name node)) ")"))) + ;; inside a def, cache the interned var cell in a per-site cell so the + ;; name lookup (string-append + hash) runs once, not per access; the + ;; cell is stable and def-var! mutates its root in place, so this stays + ;; correct under redefinition. Read through var-cell-deref — the + ;; cell-based var-deref: binding-aware (a thread-bound dynamic var + ;; resolves to its binding) AND lenient on an unbound root (the strict + ;; jolt-var-get throws on a forward-declared var). Outside a def, + ;; resolve per access. + :else + (let [cells @cache-cells + nslit (chez-str-lit (:ns node)) nmlit (chez-str-lit (:name node))] + (if (and @var-cache? cells) + (let [c (fresh-label "_vc$")] + (swap! cells conj c) + (str "(var-cell-deref (or " c " (let ((_v (jolt-var " nslit " " nmlit "))) (set! " c " _v) _v)))")) + (str "(var-deref " nslit " " nmlit ")"))))) :the-var (str "(jolt-var " (chez-str-lit (:ns node)) " " (chez-str-lit (:name node)) ")") ;; (set! *var* val) -> set the var's innermost binding (else root); returns val. :set-var (str "(jolt-var-set " (emit (:the-var node)) " " (emit (:val node)) ")") @@ -770,10 +808,10 @@ (str "(declare-var! " (chez-str-lit (:ns node)) " " (chez-str-lit (:name node)) ")") (jmeta-nonempty? (:meta node)) (str "(def-var-with-meta! " (chez-str-lit (:ns node)) " " (chez-str-lit (:name node)) " " - (emit (:init node)) " " (emit-def-meta node) ")") + (emit-with-cells #(emit (:init node))) " " (emit-def-meta node) ")") :else (str "(def-var! " (chez-str-lit (:ns node)) " " (chez-str-lit (:name node)) " " - (emit (:init node)) ")")) + (emit-with-cells #(emit (:init node))) ")")) (throw (ex-info (str "emit: op not yet ported / unhandled: " (pr-str (:op node))) {})))) ;; ^:dynamic / ^:redef on a def opts it out of direct-linking: it stays redefinable, @@ -786,45 +824,53 @@ ;; Off direct-link mode this is exactly `emit`, so the seed mint and runtime eval are ;; byte-unchanged. Nested defs (a defonce's inner def) never reach a top-level branch ;; here, so they stay indirect — a `define` would be illegal in their position. +;; Emit a def, wrapping its init in a let that binds each per-site cache cell +;; (var-ref + devirt) so a hot loop's lookups resolve once into the def's closure. +;; Runs in BOTH modes; in direct-link mode a non-opt-out def also binds jv$ +;; and registers it for app->app direct linking + a source-map frame. +(defn- emit-def-cached [node] + (let [ns (:ns node) nm (:name node) + dl? (and @direct-link? (not (dl-opt-out? (:meta node)))) + b (dl-name ns nm) + fn? (= :fn (:op (:init node))) + ;; A fn def gets a source-registry entry so a native backtrace can map its + ;; frame to ns/name (file:line). Chez names the frame by whatever emit-fn + ;; binds the lambda to: a NAMED fn (defn, or (fn foo …)) gets a letrec + ;; self-binding = munge-name of the fn's own name; an ANONYMOUS fn def has + ;; no letrec, so the lambda sits directly under (define jv$ns$name …) and + ;; takes that name. Register under whichever Chez will report. + pos (:pos node) + frame-name (when fn? (if-let [fnm (:name (:init node))] (munge-name fnm) b)) + reg (when (and dl? fn? pos) + (str " (jolt-register-source! " (chez-str-lit frame-name) " " + (chez-str-lit ns) " " (chez-str-lit nm) " " + (if (get pos :file) (chez-str-lit (get pos :file)) "jolt-nil") " " + (or (get pos :line) 0) ")")) + ;; register before emitting the init so a self-referential body direct-links. + _ (when dl? (swap! direct-link-defined conj (dl-fqn ns nm)) + (when fn? (swap! direct-link-fns conj (dl-fqn ns nm)))) + init (emit-with-cells #(emit (:init node)))] + (cond + dl? + (if (jmeta-nonempty? (:meta node)) + (str "(begin (define " b " " init ") (def-var-with-meta! " + (chez-str-lit ns) " " (chez-str-lit nm) " " b " " (emit-def-meta node) ")" (or reg "") ")") + (str "(begin (define " b " " init ") (def-var! " + (chez-str-lit ns) " " (chez-str-lit nm) " " b ")" (or reg "") ")")) + (jmeta-nonempty? (:meta node)) + (str "(def-var-with-meta! " (chez-str-lit ns) " " (chez-str-lit nm) " " init " " (emit-def-meta node) ")") + :else + (str "(def-var! " (chez-str-lit ns) " " (chez-str-lit nm) " " init ")")))) + (defn emit-top-form [node] (cond + ;; off direct-link (the seed mint + runtime-via-image) this is exactly `emit`, + ;; whose :def case already wraps cache cells, so the seed stays byte-unchanged. (not @direct-link?) (emit node) ;; top-level do splices: each statement/ret is itself a top-level form. (= :do (:op node)) (str "(begin " (str/join " " (map emit-top-form (:statements node))) (if (empty? (:statements node)) "" " ") (emit-top-form (:ret node)) ")") (and (= :def (:op node)) (not (:no-init node)) (not (dl-opt-out? (:meta node)))) - (let [ns (:ns node) nm (:name node) b (dl-name ns nm) - fn? (= :fn (:op (:init node))) - ;; A fn def gets a source-registry entry so a native backtrace can map its - ;; frame to ns/name (file:line). Chez names the frame by whatever emit-fn - ;; binds the lambda to: a NAMED fn (defn, or (fn foo …)) gets a letrec - ;; self-binding = munge-name of the fn's own name; an ANONYMOUS fn def has - ;; no letrec, so the lambda sits directly under (define jv$ns$name …) and - ;; takes that name. Register under whichever Chez will report. - pos (:pos node) - frame-name (when fn? - (if-let [fnm (:name (:init node))] (munge-name fnm) b)) - reg (when (and fn? pos) - (str " (jolt-register-source! " (chez-str-lit frame-name) " " - (chez-str-lit ns) " " (chez-str-lit nm) " " - (if (get pos :file) (chez-str-lit (get pos :file)) "jolt-nil") " " - (or (get pos :line) 0) ")"))] - ;; register before emitting the init so a self-referential body direct-links. - (swap! direct-link-defined conj (dl-fqn ns nm)) - (when fn? (swap! direct-link-fns conj (dl-fqn ns nm))) - (let [cells (atom []) - _ (reset! devirt-cells cells) - raw (emit (:init node)) - _ (reset! devirt-cells nil) - ;; wrap the init so each devirt site's cache cell persists across calls, - ;; shared by every invocation of this def. - init (if (seq @cells) - (str "(let (" (str/join " " (map (fn [c] (str "(" c " #f)")) @cells)) ") " raw ")") - raw)] - (if (jmeta-nonempty? (:meta node)) - (str "(begin (define " b " " init ") (def-var-with-meta! " - (chez-str-lit ns) " " (chez-str-lit nm) " " b " " (emit-def-meta node) ")" (or reg "") ")") - (str "(begin (define " b " " init ") (def-var! " - (chez-str-lit ns) " " (chez-str-lit nm) " " b ")" (or reg "") ")")))) + (emit-def-cached node) :else (emit node))) diff --git a/test/chez/corpus.edn b/test/chez/corpus.edn index 34cb06d..5ca11c6 100644 --- a/test/chez/corpus.edn +++ b/test/chez/corpus.edn @@ -1550,6 +1550,12 @@ {:suite "numbers / variadic bit ops" :label "bit-xor in value position" :expected "0" :actual "(reduce bit-xor 0 [1 2 3])"} {:suite "numbers / variadic bit ops" :label "bit-or via apply" :expected "7" :actual "(apply bit-or [1 2 4])"} {:suite "numbers / variadic bit ops" :label "unsigned-shift over a full 64-bit value" :expected "17179869183" :actual "(unsigned-bit-shift-right -1 30)"} + ;; var-reference cell caching (runtime path): a ref inside a fn caches the + ;; resolved cell, but stays correct under redefinition (cell root mutated in + ;; place) and dynamic binding (read goes through the binding-aware path). + {:suite "vars / cached reference stays correct" :label "redefinition is seen through a cached ref" :expected "2" :actual "(do (def x 1) (defn f [] x) (def x 2) (f))"} + {:suite "vars / cached reference stays correct" :label "dynamic binding is seen through a cached ref" :expected "[1 9 1]" :actual "(do (def ^:dynamic *d* 1) (defn g [] *d*) [(g) (binding [*d* 9] (g)) (g)])"} + {:suite "vars / cached reference stays correct" :label "forward reference resolves once the var is defined" :expected "42" :actual "(do (defn a [] (b)) (defn b [] 42) (a))"} {:suite "predicates / nil & boolean" :label "nil? true" :expected "true" :actual "(nil? nil)"} {:suite "predicates / nil & boolean" :label "nil? false" :expected "false" :actual "(nil? 0)"} {:suite "predicates / nil & boolean" :label "some? true" :expected "true" :actual "(some? 0)"}