From e2598280fecb7fa4ce28bd7c7e5aad6d3a3fae8e Mon Sep 17 00:00:00 2001 From: Yogthos Date: Fri, 26 Jun 2026 11:28:34 -0400 Subject: [PATCH] =?UTF-8?q?DO=20NOT=20MERGE=20=E2=80=94=20reduce-acc=20SRO?= =?UTF-8?q?A=20regresses=20(defeats=20vec-reduce)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Reduce-accumulator scalar replacement: lower (reduce (fn [acc x] body) (->Rec inits) coll) with a non-escaping record accumulator to a loop carrying the acc fields as scalar vars. Correct (run-reduce-sroa.ss 7/7, make test + shakesmoke green) but a PERF REGRESSION: ray tracer hit-all 38.4s -> ~53s. Root cause: jolt's reduce already iterates a vector with vec-reduce (seq.ss) — a tight index loop over the backing store, zero per-element allocation. Lowering to a (seq)/(first)/(next) loop allocates a seq node per element, trading hit-all's CONDITIONAL ->HitAcc allocation for a per-element seq allocation. The targeted accumulator allocation is also conditional (only on hit improvement), not the dominant per-sphere cost. Kept on this branch for reference; not merged. --- Makefile | 10 +- host/chez/run-reduce-sroa.ss | 84 ++++++++++ host/chez/seed/image.ss | 276 +++++++++++++++++-------------- jolt-core/jolt/passes/inline.clj | 152 ++++++++++++++++- 4 files changed, 390 insertions(+), 132 deletions(-) create mode 100644 host/chez/run-reduce-sroa.ss diff --git a/Makefile b/Makefile index d96ca47..400c6ef 100644 --- a/Makefile +++ b/Makefile @@ -4,7 +4,7 @@ # build step. `make test` is the full gate. `make remint` rebuilds the seed after a # source change. -.PHONY: test ci values corpus unit smoke buildsmoke selfhost sci certify ffi transient infer wp devirt fieldread numwp fieldnum directlink numeric inline shakesmoke remint +.PHONY: test ci values corpus unit smoke buildsmoke selfhost sci certify ffi transient infer wp devirt fieldread numwp fieldnum reducesroa directlink numeric inline shakesmoke remint # Full gate (dev machine). Includes the self-host byte-fixpoint, which only holds # on the same Chez that minted the seed. @@ -15,7 +15,7 @@ test: selfhost ci # lockfile) — it RUNS correctly on any Chez, but `selfhost` rebuilds it and a # different Chez version may emit byte-different (gensym/order) output, so the # byte-fixpoint is a dev-machine check, not a CI one (jolt-8479). -ci: values corpus unit smoke buildsmoke sci ffi transient infer wp devirt fieldread numwp fieldnum directlink numeric inline certify +ci: values corpus unit smoke buildsmoke sci ffi transient infer wp devirt fieldread numwp fieldnum reducesroa directlink numeric inline certify @echo "OK: CI gates passed" # Self-host fixpoint: bootstrap.ss rebuild == checked-in seed. @@ -92,6 +92,12 @@ numwp: fieldnum: @chez --script host/chez/run-fieldnum.ss +# Reduce-accumulator scalar replacement: a reduce over a non-escaping record +# accumulator lowers to a seq loop carrying the acc fields as scalar vars, so the +# per-step record allocation goes away; the result matches the ordinary reduce. +reducesroa: + @chez --script host/chez/run-reduce-sroa.ss + # Direct-linking emission: a closed-world build binds top-level app defs to jv$ # Scheme bindings and routes app->app calls/refs to them, skipping var-deref + # jolt-invoke; ^:dynamic/^:redef and nested defs opt out. diff --git a/host/chez/run-reduce-sroa.ss b/host/chez/run-reduce-sroa.ss new file mode 100644 index 0000000..800e58c --- /dev/null +++ b/host/chez/run-reduce-sroa.ss @@ -0,0 +1,84 @@ +;; run-reduce-sroa.ss — reduce-accumulator scalar replacement gate. +;; +;; A (reduce (fn [acc x] body) (->Rec inits) coll) whose accumulator is a +;; non-escaping record (read only via its fields, rebuilt each step as a same-shape +;; ctor or carried forward unchanged) lowers to a seq loop that carries the acc's +;; fields as scalar loop vars and reconstructs the record once at exit — killing the +;; per-step allocation. This is the ray tracer's hit-all pattern (a HitAcc per +;; sphere test). Pinned here: the reduce call is gone (lowered to a loop), the +;; lowered result matches the generic reduce, and non-lowerable shapes (non-record +;; init, escaping acc) keep the ordinary reduce. +;; +;; chez --script host/chez/run-reduce-sroa.ss +(import (chezscheme)) +(load "host/chez/rt.ss") +(set-chez-ns! "clojure.core") +(load "host/chez/seed/prelude.ss") +(load "host/chez/post-prelude.ss") +(set-chez-ns! "user") +(load "host/chez/host-contract.ss") +(load "host/chez/seed/image.ss") +(load "host/chez/compile-eval.ss") + +(define analyze (var-deref "jolt.analyzer" "analyze")) +(define set-record-shapes! (var-deref "jolt.passes.types" "set-record-shapes!")) +(define set-protocol-methods! (var-deref "jolt.passes.types" "set-protocol-methods!")) +(define run-passes (var-deref "jolt.passes" "run-passes")) +(define emit (var-deref "jolt.backend-scheme" "emit")) + +(define (anode src) (analyze (make-analyze-ctx "user") (jolt-ce-read src))) +(define (evals src) (jolt-compile-eval (string-append "(do " src ")") "user")) +(define (built scm-src) (eval (read (open-input-string scm-src)) (interaction-environment))) +(define (contains-sub? s sub) + (let ((n (string-length s)) (m (string-length sub))) + (let loop ((i 0)) + (cond ((> (+ i m) n) #f) + ((string=? (substring s i (+ i m)) sub) #t) + (else (loop (+ i 1))))))) + +(define fails 0) (define total 0) +(define (check label actual expected) + (set! total (+ total 1)) + (unless (equal? actual expected) + (set! fails (+ fails 1)) + (printf " FAIL ~a: got ~s expected ~s\n" label actual expected))) + +(evals "(defrecord Acc [sum cnt])") +(set-record-shapes! (chez-record-shapes-map)) +(set-protocol-methods! (jolt-hash-map)) +(set-optimize! #t) +(define (emit-opt src) (emit (run-passes (anode src) (make-analyze-ctx "user")))) + +;; canonical accumulator: a same-shape ctor in one branch, the acc carried forward +;; in the other. Only the fields of acc are read; acc never escapes. +(define run-src + "(def run (fn [xs] (:sum (reduce (fn [acc x] (if (> x 0) (->Acc (+ (:sum acc) x) (+ (:cnt acc) 1)) acc)) (->Acc 0 0) xs))))") +(define run-scm (emit-opt run-src)) +(check "reduce accumulator lowered (no reduce call)" (contains-sub? run-scm "reduce") #f) +(built run-scm) +(check "lowered result matches generic" + (jolt-invoke (var-deref "user" "run") (jolt-vector 1 -2 3 4)) + (evals "(:sum (reduce (fn [acc x] (if (> x 0) (->Acc (+ (:sum acc) x) (+ (:cnt acc) 1)) acc)) (->Acc 0 0) [1 -2 3 4]))")) + +;; a reduce over a record acc that reads BOTH fields at the end still matches. +(define cnt-src + "(def cntr (fn [xs] (:cnt (reduce (fn [acc x] (->Acc (+ (:sum acc) x) (+ (:cnt acc) 1))) (->Acc 0 0) xs))))") +(define cnt-scm (emit-opt cnt-src)) +(check "second accumulator lowered" (contains-sub? cnt-scm "reduce") #f) +(built cnt-scm) +(check "count accumulator correct" (jolt-invoke (var-deref "user" "cntr") (jolt-vector 5 5 5 5)) 4) + +;; empty coll returns the init (reduce semantics): (:sum (->Acc 0 0)) = 0 +(check "empty coll returns init" (jolt-invoke (var-deref "user" "run") (jolt-vector)) 0) + +;; --- negatives: shapes that must NOT be lowered keep the ordinary reduce -------- +;; non-record init +(check "non-record reduce untouched" + (contains-sub? (emit-opt "(def sm (fn [xs] (reduce (fn [acc x] (+ acc x)) 0 xs)))") "reduce") #t) +;; acc escapes (passed whole to a fn) +(check "escaping-acc reduce untouched" + (contains-sub? (emit-opt "(def esc (fn [xs] (reduce (fn [acc x] (do (identity acc) (->Acc (+ (:sum acc) x) (:cnt acc)))) (->Acc 0 0) xs)))") "reduce") #t) + +(if (= fails 0) + (begin (printf "reduce-sroa gate: ~a/~a passed\n" total total) (exit 0)) + (begin (printf "reduce-sroa gate: ~a/~a passed (~a failed)\n" (- total fails) total fails) (exit 1))) diff --git a/host/chez/seed/image.ss b/host/chez/seed/image.ss index 64a6480..2a4b776 100644 --- a/host/chez/seed/image.ss +++ b/host/chez/seed/image.ss @@ -1,271 +1,271 @@ (guard (e (#t #f)) - (def-var! "jolt.ir" "const" (letrec ((const (lambda (v) (let fnrec7503 ((v v)) (let* ((_o$7504 (keyword #f "op")) (_o$7505 (keyword #f "const")) (_o$7506 (keyword #f "val")) (_o$7507 v)) (jolt-hash-map _o$7504 _o$7505 _o$7506 _o$7507)))))) const))) + (def-var! "jolt.ir" "const" (letrec ((const (lambda (v) (let fnrec7626 ((v v)) (let* ((_o$7627 (keyword #f "op")) (_o$7628 (keyword #f "const")) (_o$7629 (keyword #f "val")) (_o$7630 v)) (jolt-hash-map _o$7627 _o$7628 _o$7629 _o$7630)))))) const))) (guard (e (#t #f)) - (def-var! "jolt.ir" "local" (letrec ((local (lambda (name) (let fnrec7508 ((name name)) (let* ((_o$7509 (keyword #f "op")) (_o$7510 (keyword #f "local")) (_o$7511 (keyword #f "name")) (_o$7512 name)) (jolt-hash-map _o$7509 _o$7510 _o$7511 _o$7512)))))) local))) + (def-var! "jolt.ir" "local" (letrec ((local (lambda (name) (let fnrec7631 ((name name)) (let* ((_o$7632 (keyword #f "op")) (_o$7633 (keyword #f "local")) (_o$7634 (keyword #f "name")) (_o$7635 name)) (jolt-hash-map _o$7632 _o$7633 _o$7634 _o$7635)))))) local))) (guard (e (#t #f)) - (def-var! "jolt.ir" "var-ref" (letrec ((var-ref (lambda (ns name) (let fnrec7513 ((ns ns) (name name)) (let* ((_o$7514 (keyword #f "op")) (_o$7515 (keyword #f "var")) (_o$7516 (keyword #f "ns")) (_o$7517 ns) (_o$7518 (keyword #f "name")) (_o$7519 name)) (jolt-hash-map _o$7514 _o$7515 _o$7516 _o$7517 _o$7518 _o$7519)))))) var-ref))) + (def-var! "jolt.ir" "var-ref" (letrec ((var-ref (lambda (ns name) (let fnrec7636 ((ns ns) (name name)) (let* ((_o$7637 (keyword #f "op")) (_o$7638 (keyword #f "var")) (_o$7639 (keyword #f "ns")) (_o$7640 ns) (_o$7641 (keyword #f "name")) (_o$7642 name)) (jolt-hash-map _o$7637 _o$7638 _o$7639 _o$7640 _o$7641 _o$7642)))))) var-ref))) (guard (e (#t #f)) - (def-var! "jolt.ir" "the-var" (letrec ((the-var (lambda (ns name) (let fnrec7520 ((ns ns) (name name)) (let* ((_o$7521 (keyword #f "op")) (_o$7522 (keyword #f "the-var")) (_o$7523 (keyword #f "ns")) (_o$7524 ns) (_o$7525 (keyword #f "name")) (_o$7526 name)) (jolt-hash-map _o$7521 _o$7522 _o$7523 _o$7524 _o$7525 _o$7526)))))) the-var))) + (def-var! "jolt.ir" "the-var" (letrec ((the-var (lambda (ns name) (let fnrec7643 ((ns ns) (name name)) (let* ((_o$7644 (keyword #f "op")) (_o$7645 (keyword #f "the-var")) (_o$7646 (keyword #f "ns")) (_o$7647 ns) (_o$7648 (keyword #f "name")) (_o$7649 name)) (jolt-hash-map _o$7644 _o$7645 _o$7646 _o$7647 _o$7648 _o$7649)))))) the-var))) (guard (e (#t #f)) - (def-var! "jolt.ir" "host-ref" (letrec ((host-ref (lambda (name) (let fnrec7527 ((name name)) (let* ((_o$7528 (keyword #f "op")) (_o$7529 (keyword #f "host")) (_o$7530 (keyword #f "name")) (_o$7531 name)) (jolt-hash-map _o$7528 _o$7529 _o$7530 _o$7531)))))) host-ref))) + (def-var! "jolt.ir" "host-ref" (letrec ((host-ref (lambda (name) (let fnrec7650 ((name name)) (let* ((_o$7651 (keyword #f "op")) (_o$7652 (keyword #f "host")) (_o$7653 (keyword #f "name")) (_o$7654 name)) (jolt-hash-map _o$7651 _o$7652 _o$7653 _o$7654)))))) host-ref))) (guard (e (#t #f)) - (def-var! "jolt.ir" "host-static" (letrec ((host-static (lambda (class member) (let fnrec7532 ((class class) (member member)) (let* ((_o$7533 (keyword #f "op")) (_o$7534 (keyword #f "host-static")) (_o$7535 (keyword #f "class")) (_o$7536 class) (_o$7537 (keyword #f "member")) (_o$7538 member)) (jolt-hash-map _o$7533 _o$7534 _o$7535 _o$7536 _o$7537 _o$7538)))))) host-static))) + (def-var! "jolt.ir" "host-static" (letrec ((host-static (lambda (class member) (let fnrec7655 ((class class) (member member)) (let* ((_o$7656 (keyword #f "op")) (_o$7657 (keyword #f "host-static")) (_o$7658 (keyword #f "class")) (_o$7659 class) (_o$7660 (keyword #f "member")) (_o$7661 member)) (jolt-hash-map _o$7656 _o$7657 _o$7658 _o$7659 _o$7660 _o$7661)))))) host-static))) (guard (e (#t #f)) - (def-var! "jolt.ir" "host-new" (letrec ((host-new (lambda (class args) (let fnrec7539 ((class class) (args args)) (let* ((_o$7540 (keyword #f "op")) (_o$7541 (keyword #f "host-new")) (_o$7542 (keyword #f "class")) (_o$7543 class) (_o$7544 (keyword #f "args")) (_o$7545 args)) (jolt-hash-map _o$7540 _o$7541 _o$7542 _o$7543 _o$7544 _o$7545)))))) host-new))) + (def-var! "jolt.ir" "host-new" (letrec ((host-new (lambda (class args) (let fnrec7662 ((class class) (args args)) (let* ((_o$7663 (keyword #f "op")) (_o$7664 (keyword #f "host-new")) (_o$7665 (keyword #f "class")) (_o$7666 class) (_o$7667 (keyword #f "args")) (_o$7668 args)) (jolt-hash-map _o$7663 _o$7664 _o$7665 _o$7666 _o$7667 _o$7668)))))) host-new))) (guard (e (#t #f)) - (def-var! "jolt.ir" "if-node" (letrec ((if-node (lambda (test then _else) (let fnrec7546 ((test test) (then then) (_else _else)) (let* ((_o$7547 (keyword #f "op")) (_o$7548 (keyword #f "if")) (_o$7549 (keyword #f "test")) (_o$7550 test) (_o$7551 (keyword #f "then")) (_o$7552 then) (_o$7553 (keyword #f "else")) (_o$7554 _else)) (jolt-hash-map _o$7547 _o$7548 _o$7549 _o$7550 _o$7551 _o$7552 _o$7553 _o$7554)))))) if-node))) + (def-var! "jolt.ir" "if-node" (letrec ((if-node (lambda (test then _else) (let fnrec7669 ((test test) (then then) (_else _else)) (let* ((_o$7670 (keyword #f "op")) (_o$7671 (keyword #f "if")) (_o$7672 (keyword #f "test")) (_o$7673 test) (_o$7674 (keyword #f "then")) (_o$7675 then) (_o$7676 (keyword #f "else")) (_o$7677 _else)) (jolt-hash-map _o$7670 _o$7671 _o$7672 _o$7673 _o$7674 _o$7675 _o$7676 _o$7677)))))) if-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "do-node" (letrec ((do-node (lambda (statements ret) (let fnrec7555 ((statements statements) (ret ret)) (let* ((_o$7556 (keyword #f "op")) (_o$7557 (keyword #f "do")) (_o$7558 (keyword #f "statements")) (_o$7559 statements) (_o$7560 (keyword #f "ret")) (_o$7561 ret)) (jolt-hash-map _o$7556 _o$7557 _o$7558 _o$7559 _o$7560 _o$7561)))))) do-node))) + (def-var! "jolt.ir" "do-node" (letrec ((do-node (lambda (statements ret) (let fnrec7678 ((statements statements) (ret ret)) (let* ((_o$7679 (keyword #f "op")) (_o$7680 (keyword #f "do")) (_o$7681 (keyword #f "statements")) (_o$7682 statements) (_o$7683 (keyword #f "ret")) (_o$7684 ret)) (jolt-hash-map _o$7679 _o$7680 _o$7681 _o$7682 _o$7683 _o$7684)))))) do-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "invoke" (letrec ((invoke (lambda (f args) (let fnrec7562 ((f f) (args args)) (let* ((_o$7563 (keyword #f "op")) (_o$7564 (keyword #f "invoke")) (_o$7565 (keyword #f "fn")) (_o$7566 f) (_o$7567 (keyword #f "args")) (_o$7568 args)) (jolt-hash-map _o$7563 _o$7564 _o$7565 _o$7566 _o$7567 _o$7568)))))) invoke))) + (def-var! "jolt.ir" "invoke" (letrec ((invoke (lambda (f args) (let fnrec7685 ((f f) (args args)) (let* ((_o$7686 (keyword #f "op")) (_o$7687 (keyword #f "invoke")) (_o$7688 (keyword #f "fn")) (_o$7689 f) (_o$7690 (keyword #f "args")) (_o$7691 args)) (jolt-hash-map _o$7686 _o$7687 _o$7688 _o$7689 _o$7690 _o$7691)))))) invoke))) (guard (e (#t #f)) - (def-var! "jolt.ir" "def-node" (letrec ((def-node (case-lambda ((ns name init) (let fnrec7569 ((ns ns) (name name) (init init)) (let* ((_o$7570 (keyword #f "op")) (_o$7571 (keyword #f "def")) (_o$7572 (keyword #f "ns")) (_o$7573 ns) (_o$7574 (keyword #f "name")) (_o$7575 name) (_o$7576 (keyword #f "init")) (_o$7577 init)) (jolt-hash-map _o$7570 _o$7571 _o$7572 _o$7573 _o$7574 _o$7575 _o$7576 _o$7577)))) ((ns name init meta) (let fnrec7578 ((ns ns) (name name) (init init) (meta meta)) (if (jolt-truthy? meta) (let* ((_o$7579 (keyword #f "op")) (_o$7580 (keyword #f "def")) (_o$7581 (keyword #f "ns")) (_o$7582 ns) (_o$7583 (keyword #f "name")) (_o$7584 name) (_o$7585 (keyword #f "init")) (_o$7586 init) (_o$7587 (keyword #f "meta")) (_o$7588 meta)) (jolt-hash-map _o$7579 _o$7580 _o$7581 _o$7582 _o$7583 _o$7584 _o$7585 _o$7586 _o$7587 _o$7588)) (let* ((_o$7589 (keyword #f "op")) (_o$7590 (keyword #f "def")) (_o$7591 (keyword #f "ns")) (_o$7592 ns) (_o$7593 (keyword #f "name")) (_o$7594 name) (_o$7595 (keyword #f "init")) (_o$7596 init)) (jolt-hash-map _o$7589 _o$7590 _o$7591 _o$7592 _o$7593 _o$7594 _o$7595 _o$7596)))))))) def-node))) + (def-var! "jolt.ir" "def-node" (letrec ((def-node (case-lambda ((ns name init) (let fnrec7692 ((ns ns) (name name) (init init)) (let* ((_o$7693 (keyword #f "op")) (_o$7694 (keyword #f "def")) (_o$7695 (keyword #f "ns")) (_o$7696 ns) (_o$7697 (keyword #f "name")) (_o$7698 name) (_o$7699 (keyword #f "init")) (_o$7700 init)) (jolt-hash-map _o$7693 _o$7694 _o$7695 _o$7696 _o$7697 _o$7698 _o$7699 _o$7700)))) ((ns name init meta) (let fnrec7701 ((ns ns) (name name) (init init) (meta meta)) (if (jolt-truthy? meta) (let* ((_o$7702 (keyword #f "op")) (_o$7703 (keyword #f "def")) (_o$7704 (keyword #f "ns")) (_o$7705 ns) (_o$7706 (keyword #f "name")) (_o$7707 name) (_o$7708 (keyword #f "init")) (_o$7709 init) (_o$7710 (keyword #f "meta")) (_o$7711 meta)) (jolt-hash-map _o$7702 _o$7703 _o$7704 _o$7705 _o$7706 _o$7707 _o$7708 _o$7709 _o$7710 _o$7711)) (let* ((_o$7712 (keyword #f "op")) (_o$7713 (keyword #f "def")) (_o$7714 (keyword #f "ns")) (_o$7715 ns) (_o$7716 (keyword #f "name")) (_o$7717 name) (_o$7718 (keyword #f "init")) (_o$7719 init)) (jolt-hash-map _o$7712 _o$7713 _o$7714 _o$7715 _o$7716 _o$7717 _o$7718 _o$7719)))))))) def-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "let-node" (letrec ((let-node (lambda (bindings body) (let fnrec7597 ((bindings bindings) (body body)) (let* ((_o$7598 (keyword #f "op")) (_o$7599 (keyword #f "let")) (_o$7600 (keyword #f "bindings")) (_o$7601 bindings) (_o$7602 (keyword #f "body")) (_o$7603 body)) (jolt-hash-map _o$7598 _o$7599 _o$7600 _o$7601 _o$7602 _o$7603)))))) let-node))) + (def-var! "jolt.ir" "let-node" (letrec ((let-node (lambda (bindings body) (let fnrec7720 ((bindings bindings) (body body)) (let* ((_o$7721 (keyword #f "op")) (_o$7722 (keyword #f "let")) (_o$7723 (keyword #f "bindings")) (_o$7724 bindings) (_o$7725 (keyword #f "body")) (_o$7726 body)) (jolt-hash-map _o$7721 _o$7722 _o$7723 _o$7724 _o$7725 _o$7726)))))) let-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "fn-node" (letrec ((fn-node (lambda (name arities) (let fnrec7604 ((name name) (arities arities)) (if (jolt-truthy? name) (let* ((_o$7605 (keyword #f "op")) (_o$7606 (keyword #f "fn")) (_o$7607 (keyword #f "name")) (_o$7608 name) (_o$7609 (keyword #f "arities")) (_o$7610 arities)) (jolt-hash-map _o$7605 _o$7606 _o$7607 _o$7608 _o$7609 _o$7610)) (let* ((_o$7611 (keyword #f "op")) (_o$7612 (keyword #f "fn")) (_o$7613 (keyword #f "arities")) (_o$7614 arities)) (jolt-hash-map _o$7611 _o$7612 _o$7613 _o$7614))))))) fn-node))) + (def-var! "jolt.ir" "fn-node" (letrec ((fn-node (lambda (name arities) (let fnrec7727 ((name name) (arities arities)) (if (jolt-truthy? name) (let* ((_o$7728 (keyword #f "op")) (_o$7729 (keyword #f "fn")) (_o$7730 (keyword #f "name")) (_o$7731 name) (_o$7732 (keyword #f "arities")) (_o$7733 arities)) (jolt-hash-map _o$7728 _o$7729 _o$7730 _o$7731 _o$7732 _o$7733)) (let* ((_o$7734 (keyword #f "op")) (_o$7735 (keyword #f "fn")) (_o$7736 (keyword #f "arities")) (_o$7737 arities)) (jolt-hash-map _o$7734 _o$7735 _o$7736 _o$7737))))))) fn-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "vector-node" (letrec ((vector-node (lambda (items) (let fnrec7615 ((items items)) (let* ((_o$7616 (keyword #f "op")) (_o$7617 (keyword #f "vector")) (_o$7618 (keyword #f "items")) (_o$7619 items)) (jolt-hash-map _o$7616 _o$7617 _o$7618 _o$7619)))))) vector-node))) + (def-var! "jolt.ir" "vector-node" (letrec ((vector-node (lambda (items) (let fnrec7738 ((items items)) (let* ((_o$7739 (keyword #f "op")) (_o$7740 (keyword #f "vector")) (_o$7741 (keyword #f "items")) (_o$7742 items)) (jolt-hash-map _o$7739 _o$7740 _o$7741 _o$7742)))))) vector-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "map-node" (letrec ((map-node (lambda (pairs) (let fnrec7620 ((pairs pairs)) (let* ((_o$7621 (keyword #f "op")) (_o$7622 (keyword #f "map")) (_o$7623 (keyword #f "pairs")) (_o$7624 pairs)) (jolt-hash-map _o$7621 _o$7622 _o$7623 _o$7624)))))) map-node))) + (def-var! "jolt.ir" "map-node" (letrec ((map-node (lambda (pairs) (let fnrec7743 ((pairs pairs)) (let* ((_o$7744 (keyword #f "op")) (_o$7745 (keyword #f "map")) (_o$7746 (keyword #f "pairs")) (_o$7747 pairs)) (jolt-hash-map _o$7744 _o$7745 _o$7746 _o$7747)))))) map-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "set-node" (letrec ((set-node (lambda (items) (let fnrec7625 ((items items)) (let* ((_o$7626 (keyword #f "op")) (_o$7627 (keyword #f "set")) (_o$7628 (keyword #f "items")) (_o$7629 items)) (jolt-hash-map _o$7626 _o$7627 _o$7628 _o$7629)))))) set-node))) + (def-var! "jolt.ir" "set-node" (letrec ((set-node (lambda (items) (let fnrec7748 ((items items)) (let* ((_o$7749 (keyword #f "op")) (_o$7750 (keyword #f "set")) (_o$7751 (keyword #f "items")) (_o$7752 items)) (jolt-hash-map _o$7749 _o$7750 _o$7751 _o$7752)))))) set-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "quote-node" (letrec ((quote-node (lambda (form) (let fnrec7630 ((form form)) (let* ((_o$7631 (keyword #f "op")) (_o$7632 (keyword #f "quote")) (_o$7633 (keyword #f "form")) (_o$7634 form)) (jolt-hash-map _o$7631 _o$7632 _o$7633 _o$7634)))))) quote-node))) + (def-var! "jolt.ir" "quote-node" (letrec ((quote-node (lambda (form) (let fnrec7753 ((form form)) (let* ((_o$7754 (keyword #f "op")) (_o$7755 (keyword #f "quote")) (_o$7756 (keyword #f "form")) (_o$7757 form)) (jolt-hash-map _o$7754 _o$7755 _o$7756 _o$7757)))))) quote-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "throw-node" (letrec ((throw-node (lambda (expr) (let fnrec7635 ((expr expr)) (let* ((_o$7636 (keyword #f "op")) (_o$7637 (keyword #f "throw")) (_o$7638 (keyword #f "expr")) (_o$7639 expr)) (jolt-hash-map _o$7636 _o$7637 _o$7638 _o$7639)))))) throw-node))) + (def-var! "jolt.ir" "throw-node" (letrec ((throw-node (lambda (expr) (let fnrec7758 ((expr expr)) (let* ((_o$7759 (keyword #f "op")) (_o$7760 (keyword #f "throw")) (_o$7761 (keyword #f "expr")) (_o$7762 expr)) (jolt-hash-map _o$7759 _o$7760 _o$7761 _o$7762)))))) throw-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "coerce-node" (letrec ((coerce-node (lambda (kind expr) (let fnrec7640 ((kind kind) (expr expr)) (let* ((_o$7641 (keyword #f "op")) (_o$7642 (keyword #f "coerce")) (_o$7643 (keyword #f "kind")) (_o$7644 kind) (_o$7645 (keyword #f "expr")) (_o$7646 expr)) (jolt-hash-map _o$7641 _o$7642 _o$7643 _o$7644 _o$7645 _o$7646)))))) coerce-node))) + (def-var! "jolt.ir" "coerce-node" (letrec ((coerce-node (lambda (kind expr) (let fnrec7763 ((kind kind) (expr expr)) (let* ((_o$7764 (keyword #f "op")) (_o$7765 (keyword #f "coerce")) (_o$7766 (keyword #f "kind")) (_o$7767 kind) (_o$7768 (keyword #f "expr")) (_o$7769 expr)) (jolt-hash-map _o$7764 _o$7765 _o$7766 _o$7767 _o$7768 _o$7769)))))) coerce-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "map-ir-children" (letrec ((map-ir-children (lambda (f node) (let fnrec7647 ((f f) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$7648 node) (_a$7649 (keyword #f "test")) (_a$7650 (jolt-invoke f (jolt-get node (keyword #f "test")))) (_a$7651 (keyword #f "then")) (_a$7652 (jolt-invoke f (jolt-get node (keyword #f "then")))) (_a$7653 (keyword #f "else")) (_a$7654 (jolt-invoke f (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$7648 _a$7649 _a$7650 _a$7651 _a$7652 _a$7653 _a$7654)) (if (jolt= op (keyword #f "do")) (let* ((_a$7655 node) (_a$7656 (keyword #f "statements")) (_a$7657 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "statements")))) (_a$7658 (keyword #f "ret")) (_a$7659 (jolt-invoke f (jolt-get node (keyword #f "ret"))))) (jolt-assoc _a$7655 _a$7656 _a$7657 _a$7658 _a$7659)) (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$7660 node) (_a$7661 (keyword #f "obj")) (_a$7662 (jolt-invoke f (jolt-get node (keyword #f "obj")))) (_a$7663 (keyword #f "val")) (_a$7664 (jolt-invoke f (jolt-get node (keyword #f "val"))))) (jolt-assoc _a$7660 _a$7661 _a$7662 _a$7663 _a$7664)) (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$7665 node) (_a$7666 (keyword #f "fn")) (_a$7667 (jolt-invoke f (jolt-get node (keyword #f "fn")))) (_a$7668 (keyword #f "args")) (_a$7669 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$7665 _a$7666 _a$7667 _a$7668 _a$7669)) (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$7673 (var-deref "clojure.core" "mapv")) (_a$7674 (lambda (pr) (let fnrec7670 ((pr pr)) (let* ((_o$7671 (jolt-invoke f (jolt-nth pr 0))) (_o$7672 (jolt-invoke f (jolt-nth pr 1)))) (jolt-vector _o$7671 _o$7672))))) (_a$7675 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$7673 _a$7674 _a$7675))) (if (jolt= op (keyword #f "let")) (let* ((_a$7682 node) (_a$7683 (keyword #f "bindings")) (_a$7684 (let* ((_a$7679 (var-deref "clojure.core" "mapv")) (_a$7680 (lambda (b) (let fnrec7676 ((b b)) (let* ((_o$7677 (jolt-nth b 0)) (_o$7678 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$7677 _o$7678))))) (_a$7681 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$7679 _a$7680 _a$7681))) (_a$7685 (keyword #f "body")) (_a$7686 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$7682 _a$7683 _a$7684 _a$7685 _a$7686)) (if (jolt= op (keyword #f "loop")) (let* ((_a$7693 node) (_a$7694 (keyword #f "bindings")) (_a$7695 (let* ((_a$7690 (var-deref "clojure.core" "mapv")) (_a$7691 (lambda (b) (let fnrec7687 ((b b)) (let* ((_o$7688 (jolt-nth b 0)) (_o$7689 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$7688 _o$7689))))) (_a$7692 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$7690 _a$7691 _a$7692))) (_a$7696 (keyword #f "body")) (_a$7697 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$7693 _a$7694 _a$7695 _a$7696 _a$7697)) (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$7699 (var-deref "clojure.core" "mapv")) (_a$7700 (lambda (a) (let fnrec7698 ((a a)) (jolt-assoc a (keyword #f "body") (jolt-invoke f (jolt-get a (keyword #f "body"))))))) (_a$7701 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$7699 _a$7700 _a$7701))) (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$7702 node) (_a$7703 (keyword #f "target")) (_a$7704 (jolt-invoke f (jolt-get node (keyword #f "target")))) (_a$7705 (keyword #f "args")) (_a$7706 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$7702 _a$7703 _a$7704 _a$7705 _a$7706)) (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 fnrec7770 ((f f) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$7771 node) (_a$7772 (keyword #f "test")) (_a$7773 (jolt-invoke f (jolt-get node (keyword #f "test")))) (_a$7774 (keyword #f "then")) (_a$7775 (jolt-invoke f (jolt-get node (keyword #f "then")))) (_a$7776 (keyword #f "else")) (_a$7777 (jolt-invoke f (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$7771 _a$7772 _a$7773 _a$7774 _a$7775 _a$7776 _a$7777)) (if (jolt= op (keyword #f "do")) (let* ((_a$7778 node) (_a$7779 (keyword #f "statements")) (_a$7780 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "statements")))) (_a$7781 (keyword #f "ret")) (_a$7782 (jolt-invoke f (jolt-get node (keyword #f "ret"))))) (jolt-assoc _a$7778 _a$7779 _a$7780 _a$7781 _a$7782)) (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$7783 node) (_a$7784 (keyword #f "obj")) (_a$7785 (jolt-invoke f (jolt-get node (keyword #f "obj")))) (_a$7786 (keyword #f "val")) (_a$7787 (jolt-invoke f (jolt-get node (keyword #f "val"))))) (jolt-assoc _a$7783 _a$7784 _a$7785 _a$7786 _a$7787)) (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$7788 node) (_a$7789 (keyword #f "fn")) (_a$7790 (jolt-invoke f (jolt-get node (keyword #f "fn")))) (_a$7791 (keyword #f "args")) (_a$7792 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$7788 _a$7789 _a$7790 _a$7791 _a$7792)) (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$7796 (var-deref "clojure.core" "mapv")) (_a$7797 (lambda (pr) (let fnrec7793 ((pr pr)) (let* ((_o$7794 (jolt-invoke f (jolt-nth pr 0))) (_o$7795 (jolt-invoke f (jolt-nth pr 1)))) (jolt-vector _o$7794 _o$7795))))) (_a$7798 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$7796 _a$7797 _a$7798))) (if (jolt= op (keyword #f "let")) (let* ((_a$7805 node) (_a$7806 (keyword #f "bindings")) (_a$7807 (let* ((_a$7802 (var-deref "clojure.core" "mapv")) (_a$7803 (lambda (b) (let fnrec7799 ((b b)) (let* ((_o$7800 (jolt-nth b 0)) (_o$7801 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$7800 _o$7801))))) (_a$7804 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$7802 _a$7803 _a$7804))) (_a$7808 (keyword #f "body")) (_a$7809 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$7805 _a$7806 _a$7807 _a$7808 _a$7809)) (if (jolt= op (keyword #f "loop")) (let* ((_a$7816 node) (_a$7817 (keyword #f "bindings")) (_a$7818 (let* ((_a$7813 (var-deref "clojure.core" "mapv")) (_a$7814 (lambda (b) (let fnrec7810 ((b b)) (let* ((_o$7811 (jolt-nth b 0)) (_o$7812 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$7811 _o$7812))))) (_a$7815 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$7813 _a$7814 _a$7815))) (_a$7819 (keyword #f "body")) (_a$7820 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$7816 _a$7817 _a$7818 _a$7819 _a$7820)) (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$7822 (var-deref "clojure.core" "mapv")) (_a$7823 (lambda (a) (let fnrec7821 ((a a)) (jolt-assoc a (keyword #f "body") (jolt-invoke f (jolt-get a (keyword #f "body"))))))) (_a$7824 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$7822 _a$7823 _a$7824))) (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$7825 node) (_a$7826 (keyword #f "target")) (_a$7827 (jolt-invoke f (jolt-get node (keyword #f "target")))) (_a$7828 (keyword #f "args")) (_a$7829 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$7825 _a$7826 _a$7827 _a$7828 _a$7829)) (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 fnrec7707 ((f f) (acc acc) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$7711 f) (_a$7712 (let* ((_a$7708 f) (_a$7709 (jolt-invoke f acc (jolt-get node (keyword #f "test")))) (_a$7710 (jolt-get node (keyword #f "then")))) (jolt-invoke _a$7708 _a$7709 _a$7710))) (_a$7713 (jolt-get node (keyword #f "else")))) (jolt-invoke _a$7711 _a$7712 _a$7713)) (if (jolt= op (keyword #f "do")) (let* ((_a$7714 f) (_a$7715 (jolt-reduce f acc (jolt-get node (keyword #f "statements")))) (_a$7716 (jolt-get node (keyword #f "ret")))) (jolt-invoke _a$7714 _a$7715 _a$7716)) (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$7717 f) (_a$7718 (jolt-invoke f acc (jolt-get node (keyword #f "obj")))) (_a$7719 (jolt-get node (keyword #f "val")))) (jolt-invoke _a$7717 _a$7718 _a$7719)) (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$7720 f) (_a$7721 (jolt-invoke f acc (jolt-get node (keyword #f "fn")))) (_a$7722 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$7720 _a$7721 _a$7722)) (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$7727 (lambda (a pr) (let fnrec7723 ((a a) (pr pr)) (let* ((_a$7724 f) (_a$7725 (jolt-invoke f a (jolt-nth pr 0))) (_a$7726 (jolt-nth pr 1))) (jolt-invoke _a$7724 _a$7725 _a$7726))))) (_a$7728 acc) (_a$7729 (jolt-get node (keyword #f "pairs")))) (jolt-reduce _a$7727 _a$7728 _a$7729)) (if (jolt= op (keyword #f "let")) (let* ((_a$7734 f) (_a$7735 (let* ((_a$7731 (lambda (a b) (let fnrec7730 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$7732 acc) (_a$7733 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$7731 _a$7732 _a$7733))) (_a$7736 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$7734 _a$7735 _a$7736)) (if (jolt= op (keyword #f "loop")) (let* ((_a$7741 f) (_a$7742 (let* ((_a$7738 (lambda (a b) (let fnrec7737 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$7739 acc) (_a$7740 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$7738 _a$7739 _a$7740))) (_a$7743 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$7741 _a$7742 _a$7743)) (if (jolt= op (keyword #f "recur")) (jolt-reduce f acc (jolt-get node (keyword #f "args"))) (if (jolt= op (keyword #f "fn")) (let* ((_a$7745 (lambda (a ar) (let fnrec7744 ((a a) (ar ar)) (jolt-invoke f a (jolt-get ar (keyword #f "body")))))) (_a$7746 acc) (_a$7747 (jolt-get node (keyword #f "arities")))) (jolt-reduce _a$7745 _a$7746 _a$7747)) (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$7748 f) (_a$7749 (jolt-invoke f acc (jolt-get node (keyword #f "target")))) (_a$7750 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$7748 _a$7749 _a$7750)) (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 fnrec7830 ((f f) (acc acc) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$7834 f) (_a$7835 (let* ((_a$7831 f) (_a$7832 (jolt-invoke f acc (jolt-get node (keyword #f "test")))) (_a$7833 (jolt-get node (keyword #f "then")))) (jolt-invoke _a$7831 _a$7832 _a$7833))) (_a$7836 (jolt-get node (keyword #f "else")))) (jolt-invoke _a$7834 _a$7835 _a$7836)) (if (jolt= op (keyword #f "do")) (let* ((_a$7837 f) (_a$7838 (jolt-reduce f acc (jolt-get node (keyword #f "statements")))) (_a$7839 (jolt-get node (keyword #f "ret")))) (jolt-invoke _a$7837 _a$7838 _a$7839)) (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$7840 f) (_a$7841 (jolt-invoke f acc (jolt-get node (keyword #f "obj")))) (_a$7842 (jolt-get node (keyword #f "val")))) (jolt-invoke _a$7840 _a$7841 _a$7842)) (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$7843 f) (_a$7844 (jolt-invoke f acc (jolt-get node (keyword #f "fn")))) (_a$7845 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$7843 _a$7844 _a$7845)) (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$7850 (lambda (a pr) (let fnrec7846 ((a a) (pr pr)) (let* ((_a$7847 f) (_a$7848 (jolt-invoke f a (jolt-nth pr 0))) (_a$7849 (jolt-nth pr 1))) (jolt-invoke _a$7847 _a$7848 _a$7849))))) (_a$7851 acc) (_a$7852 (jolt-get node (keyword #f "pairs")))) (jolt-reduce _a$7850 _a$7851 _a$7852)) (if (jolt= op (keyword #f "let")) (let* ((_a$7857 f) (_a$7858 (let* ((_a$7854 (lambda (a b) (let fnrec7853 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$7855 acc) (_a$7856 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$7854 _a$7855 _a$7856))) (_a$7859 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$7857 _a$7858 _a$7859)) (if (jolt= op (keyword #f "loop")) (let* ((_a$7864 f) (_a$7865 (let* ((_a$7861 (lambda (a b) (let fnrec7860 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$7862 acc) (_a$7863 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$7861 _a$7862 _a$7863))) (_a$7866 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$7864 _a$7865 _a$7866)) (if (jolt= op (keyword #f "recur")) (jolt-reduce f acc (jolt-get node (keyword #f "args"))) (if (jolt= op (keyword #f "fn")) (let* ((_a$7868 (lambda (a ar) (let fnrec7867 ((a a) (ar ar)) (jolt-invoke f a (jolt-get ar (keyword #f "body")))))) (_a$7869 acc) (_a$7870 (jolt-get node (keyword #f "arities")))) (jolt-reduce _a$7868 _a$7869 _a$7870)) (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$7871 f) (_a$7872 (jolt-invoke f acc (jolt-get node (keyword #f "target")))) (_a$7873 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$7871 _a$7872 _a$7873)) (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$7751 "quote") (_o$7752 "if") (_o$7753 "do") (_o$7754 "def") (_o$7755 "fn*") (_o$7756 "let*") (_o$7757 "loop*") (_o$7758 "recur") (_o$7759 "throw") (_o$7760 "try") (_o$7761 "syntax-quote") (_o$7762 "var") (_o$7763 "letfn") (_o$7764 "set!") (_o$7765 "defmacro")) (jolt-hash-set _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)) (let* ((_o$7766 (keyword #f "private")) (_o$7767 #t)) (jolt-hash-map _o$7766 _o$7767)))) + (def-var-with-meta! "jolt.analyzer" "handled" (let* ((_o$7874 "quote") (_o$7875 "if") (_o$7876 "do") (_o$7877 "def") (_o$7878 "fn*") (_o$7879 "let*") (_o$7880 "loop*") (_o$7881 "recur") (_o$7882 "throw") (_o$7883 "try") (_o$7884 "syntax-quote") (_o$7885 "var") (_o$7886 "letfn") (_o$7887 "set!") (_o$7888 "defmacro")) (jolt-hash-set _o$7874 _o$7875 _o$7876 _o$7877 _o$7878 _o$7879 _o$7880 _o$7881 _o$7882 _o$7883 _o$7884 _o$7885 _o$7886 _o$7887 _o$7888)) (let* ((_o$7889 (keyword #f "private")) (_o$7890 #t)) (jolt-hash-map _o$7889 _o$7890)))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "uncompilable" (letrec ((uncompilable (lambda (why) (let fnrec7768 ((why why)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt/uncompilable: " why)))))) uncompilable))) + (def-var! "jolt.analyzer" "uncompilable" (letrec ((uncompilable (lambda (why) (let fnrec7891 ((why why)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt/uncompilable: " why)))))) uncompilable))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "gensym-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$7769 (keyword #f "private")) (_o$7770 #t)) (jolt-hash-map _o$7769 _o$7770)))) + (def-var-with-meta! "jolt.analyzer" "gensym-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$7892 (keyword #f "private")) (_o$7893 #t)) (jolt-hash-map _o$7892 _o$7893)))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "gen-name" (letrec ((gen-name (lambda (prefix) (let fnrec7771 ((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))) + (def-var! "jolt.analyzer" "gen-name" (letrec ((gen-name (lambda (prefix) (let fnrec7894 ((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))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "empty-env" (letrec ((empty-env (lambda () (let fnrec7772 () (let* ((_o$7773 (keyword #f "locals")) (_o$7774 (jolt-hash-set)) (_o$7775 (keyword #f "hints")) (_o$7776 (jolt-hash-map))) (jolt-hash-map _o$7773 _o$7774 _o$7775 _o$7776)))))) empty-env))) + (def-var! "jolt.analyzer" "empty-env" (letrec ((empty-env (lambda () (let fnrec7895 () (let* ((_o$7896 (keyword #f "locals")) (_o$7897 (jolt-hash-set)) (_o$7898 (keyword #f "hints")) (_o$7899 (jolt-hash-map))) (jolt-hash-map _o$7896 _o$7897 _o$7898 _o$7899)))))) empty-env))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "local?" (letrec ((local? (lambda (env nm) (let fnrec7777 ((env env) (nm nm)) (jolt-contains? (jolt-get env (keyword #f "locals")) nm))))) local?))) + (def-var! "jolt.analyzer" "local?" (letrec ((local? (lambda (env nm) (let fnrec7900 ((env env) (nm nm)) (jolt-contains? (jolt-get env (keyword #f "locals")) nm))))) local?))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "add-locals" (letrec ((add-locals (lambda (env names) (let fnrec7778 ((env env) (names names)) (jolt-invoke (var-deref "clojure.core" "update") env (keyword #f "locals") (lambda (p__90_) (let fnrec7779 ((p__90_ p__90_)) (jolt-reduce jolt-conj p__90_ names)))))))) add-locals))) + (def-var! "jolt.analyzer" "add-locals" (letrec ((add-locals (lambda (env names) (let fnrec7901 ((env env) (names names)) (jolt-invoke (var-deref "clojure.core" "update") env (keyword #f "locals") (lambda (p__90_) (let fnrec7902 ((p__90_ p__90_)) (jolt-reduce jolt-conj p__90_ names)))))))) add-locals))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "with-recur" (letrec ((with-recur (lambda (env name) (let fnrec7780 ((env env) (name name)) (jolt-assoc env (keyword #f "recur") name))))) with-recur))) + (def-var! "jolt.analyzer" "with-recur" (letrec ((with-recur (lambda (env name) (let fnrec7903 ((env env) (name name)) (jolt-assoc env (keyword #f "recur") name))))) with-recur))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "hint-of" (letrec ((hint-of (lambda (ctx sym) (let fnrec7781 ((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))) + (def-var! "jolt.analyzer" "hint-of" (letrec ((hint-of (lambda (ctx sym) (let fnrec7904 ((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))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "add-hint" (letrec ((add-hint (lambda (env nm h) (let fnrec7782 ((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))) + (def-var! "jolt.analyzer" "add-hint" (letrec ((add-hint (lambda (env nm h) (let fnrec7905 ((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))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "phint-of" (letrec ((phint-of (lambda (ctx sym) (let fnrec7783 ((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))) + (def-var! "jolt.analyzer" "phint-of" (letrec ((phint-of (lambda (ctx sym) (let fnrec7906 ((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))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "tag->nkind" (letrec ((tag->nkind (lambda (t) (let fnrec7784 ((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))) + (def-var! "jolt.analyzer" "tag->nkind" (letrec ((tag->nkind (lambda (t) (let fnrec7907 ((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))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "nhint-of" (letrec ((nhint-of (lambda (ctx sym) (let fnrec7785 ((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))) + (def-var! "jolt.analyzer" "nhint-of" (letrec ((nhint-of (lambda (ctx sym) (let fnrec7908 ((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))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "with-ret-nhint" (letrec ((with-ret-nhint (lambda (node kind) (let fnrec7786 ((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$7788 (var-deref "clojure.core" "mapv")) (_a$7789 (lambda (a) (let fnrec7787 ((a a)) (if (jolt-truthy? (jolt-get a (keyword #f "ret-nhint"))) a (jolt-assoc a (keyword #f "ret-nhint") kind))))) (_a$7790 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$7788 _a$7789 _a$7790))) node))))) with-ret-nhint))) + (def-var! "jolt.analyzer" "with-ret-nhint" (letrec ((with-ret-nhint (lambda (node kind) (let fnrec7909 ((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$7911 (var-deref "clojure.core" "mapv")) (_a$7912 (lambda (a) (let fnrec7910 ((a a)) (if (jolt-truthy? (jolt-get a (keyword #f "ret-nhint"))) a (jolt-assoc a (keyword #f "ret-nhint") kind))))) (_a$7913 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$7911 _a$7912 _a$7913))) node))))) with-ret-nhint))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze-seq" (letrec ((analyze-seq (lambda (ctx forms env) (let fnrec7791 ((ctx ctx) (forms forms) (env env)) (let* ((v (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__91_) (let fnrec7792 ((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$7793 (var-deref "jolt.ir" "do-node")) (_a$7794 (jolt-invoke (var-deref "clojure.core" "subvec") v 0 (jolt-dec n))) (_a$7795 (jolt-peek v))) (jolt-invoke _a$7793 _a$7794 _a$7795)) jolt-nil)))))))) analyze-seq))) + (def-var! "jolt.analyzer" "analyze-seq" (letrec ((analyze-seq (lambda (ctx forms env) (let fnrec7914 ((ctx ctx) (forms forms) (env env)) (let* ((v (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__91_) (let fnrec7915 ((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$7916 (var-deref "jolt.ir" "do-node")) (_a$7917 (jolt-invoke (var-deref "clojure.core" "subvec") v 0 (jolt-dec n))) (_a$7918 (jolt-peek v))) (jolt-invoke _a$7916 _a$7917 _a$7918)) jolt-nil)))))))) analyze-seq))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze-bindings" (letrec ((analyze-bindings (lambda (ctx bvec env) (let fnrec7796 ((ctx ctx) (bvec bvec) (env env)) (let* ((i 0) (env env) (pairs (jolt-vector))) (let loop7797 ((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$7804 (+ i 2)) (_a$7805 (let* ((_a$7798 (var-deref "jolt.analyzer" "add-hint")) (_a$7799 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector nm))) (_a$7800 nm) (_a$7801 (jolt-invoke (var-deref "jolt.analyzer" "hint-of") ctx bsym))) (jolt-invoke _a$7798 _a$7799 _a$7800 _a$7801))) (_a$7806 (jolt-conj pairs (let* ((_o$7802 nm) (_o$7803 init)) (jolt-vector _o$7802 _o$7803))))) (loop7797 _a$7804 _a$7805 _a$7806))))) (let* ((_o$7807 pairs) (_o$7808 env)) (jolt-vector _o$7807 _o$7808))))))))) analyze-bindings))) + (def-var! "jolt.analyzer" "analyze-bindings" (letrec ((analyze-bindings (lambda (ctx bvec env) (let fnrec7919 ((ctx ctx) (bvec bvec) (env env)) (let* ((i 0) (env env) (pairs (jolt-vector))) (let loop7920 ((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$7927 (+ i 2)) (_a$7928 (let* ((_a$7921 (var-deref "jolt.analyzer" "add-hint")) (_a$7922 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector nm))) (_a$7923 nm) (_a$7924 (jolt-invoke (var-deref "jolt.analyzer" "hint-of") ctx bsym))) (jolt-invoke _a$7921 _a$7922 _a$7923 _a$7924))) (_a$7929 (jolt-conj pairs (let* ((_o$7925 nm) (_o$7926 init)) (jolt-vector _o$7925 _o$7926))))) (loop7920 _a$7927 _a$7928 _a$7929))))) (let* ((_o$7930 pairs) (_o$7931 env)) (jolt-vector _o$7930 _o$7931))))))))) analyze-bindings))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "parse-params" (letrec ((parse-params (lambda (ctx pvec) (let fnrec7809 ((ctx ctx) (pvec pvec)) (let* ((i 0) (fixed (jolt-vector)) (rest-name jolt-nil) (hints (jolt-vector)) (phints (jolt-vector)) (nhints (jolt-vector))) (let loop7810 ((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$7811 (+ i 2)) (_a$7812 fixed) (_a$7813 (jolt-invoke (var-deref "jolt.host" "form-sym-name") r)) (_a$7814 hints) (_a$7815 phints) (_a$7816 nhints)) (loop7810 _a$7811 _a$7812 _a$7813 _a$7814 _a$7815 _a$7816)))) (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$7823 (jolt-inc i)) (_a$7824 (jolt-conj fixed nm)) (_a$7825 rest-name) (_a$7826 (if (jolt-truthy? h) (jolt-conj hints (let* ((_o$7817 nm) (_o$7818 h)) (jolt-vector _o$7817 _o$7818))) hints)) (_a$7827 (if (jolt-truthy? ph) (jolt-conj phints (let* ((_o$7819 nm) (_o$7820 ph)) (jolt-vector _o$7819 _o$7820))) phints)) (_a$7828 (if (jolt-truthy? nh) (jolt-conj nhints (let* ((_o$7821 nm) (_o$7822 nh)) (jolt-vector _o$7821 _o$7822))) nhints))) (loop7810 _a$7823 _a$7824 _a$7825 _a$7826 _a$7827 _a$7828)))))) (let* ((_o$7829 (keyword #f "fixed")) (_o$7830 fixed) (_o$7831 (keyword #f "rest")) (_o$7832 rest-name) (_o$7833 (keyword #f "hints")) (_o$7834 hints) (_o$7835 (keyword #f "phints")) (_o$7836 phints) (_o$7837 (keyword #f "nhints")) (_o$7838 nhints)) (jolt-hash-map _o$7829 _o$7830 _o$7831 _o$7832 _o$7833 _o$7834 _o$7835 _o$7836 _o$7837 _o$7838))))))))) parse-params))) + (def-var! "jolt.analyzer" "parse-params" (letrec ((parse-params (lambda (ctx pvec) (let fnrec7932 ((ctx ctx) (pvec pvec)) (let* ((i 0) (fixed (jolt-vector)) (rest-name jolt-nil) (hints (jolt-vector)) (phints (jolt-vector)) (nhints (jolt-vector))) (let loop7933 ((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$7934 (+ i 2)) (_a$7935 fixed) (_a$7936 (jolt-invoke (var-deref "jolt.host" "form-sym-name") r)) (_a$7937 hints) (_a$7938 phints) (_a$7939 nhints)) (loop7933 _a$7934 _a$7935 _a$7936 _a$7937 _a$7938 _a$7939)))) (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$7946 (jolt-inc i)) (_a$7947 (jolt-conj fixed nm)) (_a$7948 rest-name) (_a$7949 (if (jolt-truthy? h) (jolt-conj hints (let* ((_o$7940 nm) (_o$7941 h)) (jolt-vector _o$7940 _o$7941))) hints)) (_a$7950 (if (jolt-truthy? ph) (jolt-conj phints (let* ((_o$7942 nm) (_o$7943 ph)) (jolt-vector _o$7942 _o$7943))) phints)) (_a$7951 (if (jolt-truthy? nh) (jolt-conj nhints (let* ((_o$7944 nm) (_o$7945 nh)) (jolt-vector _o$7944 _o$7945))) nhints))) (loop7933 _a$7946 _a$7947 _a$7948 _a$7949 _a$7950 _a$7951)))))) (let* ((_o$7952 (keyword #f "fixed")) (_o$7953 fixed) (_o$7954 (keyword #f "rest")) (_o$7955 rest-name) (_o$7956 (keyword #f "hints")) (_o$7957 hints) (_o$7958 (keyword #f "phints")) (_o$7959 phints) (_o$7960 (keyword #f "nhints")) (_o$7961 nhints)) (jolt-hash-map _o$7952 _o$7953 _o$7954 _o$7955 _o$7956 _o$7957 _o$7958 _o$7959 _o$7960 _o$7961))))))))) parse-params))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "uniquify-params" (letrec ((uniquify-params (lambda (names) (let fnrec7839 ((names names)) (let* ((n (jolt-count names))) (let* ((i 0) (out (jolt-vector))) (let loop7840 ((i i) (out out)) (if (< i n) (let* ((nm (jolt-nth names i)) (dup? (let* ((j (jolt-inc i))) (let loop7841 ((j j)) (if (>= j n) #f (if (jolt= nm (jolt-nth names j)) #t (if (jolt-truthy? (keyword #f "else")) (loop7841 (jolt-inc j)) jolt-nil))))))) (let* ((_a$7842 (jolt-inc i)) (_a$7843 (jolt-conj out (if (jolt-truthy? dup?) (jolt-invoke (var-deref "jolt.analyzer" "gen-name") (jolt-invoke (var-deref "clojure.core" "str") nm "_")) nm)))) (loop7840 _a$7842 _a$7843))) out)))))))) uniquify-params))) + (def-var! "jolt.analyzer" "uniquify-params" (letrec ((uniquify-params (lambda (names) (let fnrec7962 ((names names)) (let* ((n (jolt-count names))) (let* ((i 0) (out (jolt-vector))) (let loop7963 ((i i) (out out)) (if (< i n) (let* ((nm (jolt-nth names i)) (dup? (let* ((j (jolt-inc i))) (let loop7964 ((j j)) (if (>= j n) #f (if (jolt= nm (jolt-nth names j)) #t (if (jolt-truthy? (keyword #f "else")) (loop7964 (jolt-inc j)) jolt-nil))))))) (let* ((_a$7965 (jolt-inc i)) (_a$7966 (jolt-conj out (if (jolt-truthy? dup?) (jolt-invoke (var-deref "jolt.analyzer" "gen-name") (jolt-invoke (var-deref "clojure.core" "str") nm "_")) nm)))) (loop7963 _a$7965 _a$7966))) out)))))))) uniquify-params))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze-arity" (letrec ((analyze-arity (lambda (ctx pvec body env fn-name) (let fnrec7844 ((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$7845 (var-deref "clojure.core" "str")) (_a$7846 (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (_a$7847 "/") (_a$7848 (let* ((or__26__auto fn-name)) (if (jolt-truthy? or__26__auto) or__26__auto "fn"))) (_a$7849 "--")) (jolt-invoke _a$7845 _a$7846 _a$7847 _a$7848 _a$7849)))) (names (let* ((G__142 (jolt-invoke (var-deref "clojure.core" "vec") fixed))) (let* ((G__143 (if (jolt-truthy? rst) (jolt-conj G__142 rst) G__142))) (let* ((G__144 (if (jolt-truthy? fn-name) (jolt-conj G__143 fn-name) G__143))) G__144)))) (env0 (jolt-invoke (var-deref "jolt.analyzer" "with-recur") (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names) rname)) (env* (let* ((_a$7855 (lambda (e pr) (let fnrec7850 ((e e) (pr pr)) (let* ((_a$7851 (var-deref "jolt.analyzer" "add-hint")) (_a$7852 e) (_a$7853 (jolt-nth pr 0)) (_a$7854 (jolt-nth pr 1))) (jolt-invoke _a$7851 _a$7852 _a$7853 _a$7854))))) (_a$7856 env0) (_a$7857 (jolt-get pp (keyword #f "hints")))) (jolt-reduce _a$7855 _a$7856 _a$7857))) (arity (let* ((_o$7858 (keyword #f "params")) (_o$7859 fixed) (_o$7860 (keyword #f "recur-name")) (_o$7861 rname) (_o$7862 (keyword #f "body")) (_o$7863 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx body env*))) (jolt-hash-map _o$7858 _o$7859 _o$7860 _o$7861 _o$7862 _o$7863))) (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))) + (def-var! "jolt.analyzer" "analyze-arity" (letrec ((analyze-arity (lambda (ctx pvec body env fn-name) (let fnrec7967 ((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$7968 (var-deref "clojure.core" "str")) (_a$7969 (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (_a$7970 "/") (_a$7971 (let* ((or__26__auto fn-name)) (if (jolt-truthy? or__26__auto) or__26__auto "fn"))) (_a$7972 "--")) (jolt-invoke _a$7968 _a$7969 _a$7970 _a$7971 _a$7972)))) (names (let* ((G__142 (jolt-invoke (var-deref "clojure.core" "vec") fixed))) (let* ((G__143 (if (jolt-truthy? rst) (jolt-conj G__142 rst) G__142))) (let* ((G__144 (if (jolt-truthy? fn-name) (jolt-conj G__143 fn-name) G__143))) G__144)))) (env0 (jolt-invoke (var-deref "jolt.analyzer" "with-recur") (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names) rname)) (env* (let* ((_a$7978 (lambda (e pr) (let fnrec7973 ((e e) (pr pr)) (let* ((_a$7974 (var-deref "jolt.analyzer" "add-hint")) (_a$7975 e) (_a$7976 (jolt-nth pr 0)) (_a$7977 (jolt-nth pr 1))) (jolt-invoke _a$7974 _a$7975 _a$7976 _a$7977))))) (_a$7979 env0) (_a$7980 (jolt-get pp (keyword #f "hints")))) (jolt-reduce _a$7978 _a$7979 _a$7980))) (arity (let* ((_o$7981 (keyword #f "params")) (_o$7982 fixed) (_o$7983 (keyword #f "recur-name")) (_o$7984 rname) (_o$7985 (keyword #f "body")) (_o$7986 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx body env*))) (jolt-hash-map _o$7981 _o$7982 _o$7983 _o$7984 _o$7985 _o$7986))) (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))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "strip-arglist-meta" (letrec ((strip-arglist-meta (lambda (form) (let fnrec7864 ((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))) + (def-var! "jolt.analyzer" "strip-arglist-meta" (letrec ((strip-arglist-meta (lambda (form) (let fnrec7987 ((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))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze-fn" (letrec ((analyze-fn (lambda (ctx items env) (let fnrec7865 ((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 fnrec7866 ((clause clause)) (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") clause)))) (let* ((_a$7867 (var-deref "jolt.analyzer" "analyze-arity")) (_a$7868 ctx) (_a$7869 (jolt-invoke (var-deref "jolt.analyzer" "strip-arglist-meta") (jolt-first cl))) (_a$7870 (jolt-rest cl)) (_a$7871 env) (_a$7872 fn-name)) (jolt-invoke _a$7867 _a$7868 _a$7869 _a$7870 _a$7871 _a$7872))))) rest-items)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "fn: bad params") jolt-nil)))))))) analyze-fn))) + (def-var! "jolt.analyzer" "analyze-fn" (letrec ((analyze-fn (lambda (ctx items env) (let fnrec7988 ((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 fnrec7989 ((clause clause)) (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") clause)))) (let* ((_a$7990 (var-deref "jolt.analyzer" "analyze-arity")) (_a$7991 ctx) (_a$7992 (jolt-invoke (var-deref "jolt.analyzer" "strip-arglist-meta") (jolt-first cl))) (_a$7993 (jolt-rest cl)) (_a$7994 env) (_a$7995 fn-name)) (jolt-invoke _a$7990 _a$7991 _a$7992 _a$7993 _a$7994 _a$7995))))) rest-items)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "fn: bad params") jolt-nil)))))))) analyze-fn))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.analyzer" "catch-all-names" (let* ((_o$7873 "Throwable") (_o$7874 "java.lang.Throwable") (_o$7875 "Object") (_o$7876 "java.lang.Object")) (jolt-hash-set _o$7873 _o$7874 _o$7875 _o$7876)) (let* ((_o$7877 (keyword #f "private")) (_o$7878 #t)) (jolt-hash-map _o$7877 _o$7878)))) + (def-var-with-meta! "jolt.analyzer" "catch-all-names" (let* ((_o$7996 "Throwable") (_o$7997 "java.lang.Throwable") (_o$7998 "Object") (_o$7999 "java.lang.Object")) (jolt-hash-set _o$7996 _o$7997 _o$7998 _o$7999)) (let* ((_o$8000 (keyword #f "private")) (_o$8001 #t)) (jolt-hash-map _o$8000 _o$8001)))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze-try" (letrec ((analyze-try (lambda (ctx items env) (let fnrec7879 ((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 fnrec7880 ((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$7881 (keyword #f "op")) (_o$7882 (keyword #f "try")) (_o$7883 (keyword #f "body")) (_o$7884 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-invoke (var-deref "clojure.core" "deref") body) env))) (jolt-hash-map _o$7881 _o$7882 _o$7883 _o$7884))) (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$7889 (lambda (_else cl) (let fnrec7885 ((_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$7886 (jolt-symbol #f "or")) (_a$7887 (jolt-list (jolt-symbol #f "instance?") cform evar)) (_a$7888 (jolt-list (jolt-symbol #f "__catch-broad?") fullname evar))) (jolt-list _a$7886 _a$7887 _a$7888)) letform _else)))))) (_a$7890 (jolt-list (jolt-symbol #f "throw") evar)) (_a$7891 (jolt-reverse (jolt-invoke (var-deref "clojure.core" "deref") catches)))) (jolt-reduce _a$7889 _a$7890 _a$7891)))) (jolt-assoc n (keyword #f "catch-sym") evar-name (keyword #f "catch-body") (let* ((_a$7892 (var-deref "jolt.analyzer" "analyze-seq")) (_a$7893 ctx) (_a$7894 (jolt-list dispatch)) (_a$7895 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector evar-name)))) (jolt-invoke _a$7892 _a$7893 _a$7894 _a$7895)))) 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))) + (def-var! "jolt.analyzer" "analyze-try" (letrec ((analyze-try (lambda (ctx items env) (let fnrec8002 ((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 fnrec8003 ((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$8004 (keyword #f "op")) (_o$8005 (keyword #f "try")) (_o$8006 (keyword #f "body")) (_o$8007 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-invoke (var-deref "clojure.core" "deref") body) env))) (jolt-hash-map _o$8004 _o$8005 _o$8006 _o$8007))) (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$8012 (lambda (_else cl) (let fnrec8008 ((_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$8009 (jolt-symbol #f "or")) (_a$8010 (jolt-list (jolt-symbol #f "instance?") cform evar)) (_a$8011 (jolt-list (jolt-symbol #f "__catch-broad?") fullname evar))) (jolt-list _a$8009 _a$8010 _a$8011)) letform _else)))))) (_a$8013 (jolt-list (jolt-symbol #f "throw") evar)) (_a$8014 (jolt-reverse (jolt-invoke (var-deref "clojure.core" "deref") catches)))) (jolt-reduce _a$8012 _a$8013 _a$8014)))) (jolt-assoc n (keyword #f "catch-sym") evar-name (keyword #f "catch-body") (let* ((_a$8015 (var-deref "jolt.analyzer" "analyze-seq")) (_a$8016 ctx) (_a$8017 (jolt-list dispatch)) (_a$8018 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector evar-name)))) (jolt-invoke _a$8015 _a$8016 _a$8017 _a$8018)))) 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))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze-letfn" (letrec ((analyze-letfn (lambda (ctx items env) (let fnrec7896 ((ctx ctx) (items items) (env env)) (let* ((specs (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 1)))) (names (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__92_) (let fnrec7897 ((p__92_ p__92_)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") p__92_)))))) specs)) (env* (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names)) (binds (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (spec) (let fnrec7898 ((spec spec)) (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") spec)))) (let* ((_o$7899 (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first cl))) (_o$7900 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-cons (jolt-invoke (var-deref "clojure.core" "symbol") "fn") cl) env*))) (jolt-vector _o$7899 _o$7900))))) specs))) (let* ((_o$7901 (keyword #f "op")) (_o$7902 (keyword #f "let")) (_o$7903 (keyword #f "letrec")) (_o$7904 #t) (_o$7905 (keyword #f "bindings")) (_o$7906 binds) (_o$7907 (keyword #f "body")) (_o$7908 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env*))) (jolt-hash-map _o$7901 _o$7902 _o$7903 _o$7904 _o$7905 _o$7906 _o$7907 _o$7908))))))) analyze-letfn))) + (def-var! "jolt.analyzer" "analyze-letfn" (letrec ((analyze-letfn (lambda (ctx items env) (let fnrec8019 ((ctx ctx) (items items) (env env)) (let* ((specs (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 1)))) (names (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__92_) (let fnrec8020 ((p__92_ p__92_)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") p__92_)))))) specs)) (env* (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names)) (binds (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (spec) (let fnrec8021 ((spec spec)) (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") spec)))) (let* ((_o$8022 (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first cl))) (_o$8023 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-cons (jolt-invoke (var-deref "clojure.core" "symbol") "fn") cl) env*))) (jolt-vector _o$8022 _o$8023))))) specs))) (let* ((_o$8024 (keyword #f "op")) (_o$8025 (keyword #f "let")) (_o$8026 (keyword #f "letrec")) (_o$8027 #t) (_o$8028 (keyword #f "bindings")) (_o$8029 binds) (_o$8030 (keyword #f "body")) (_o$8031 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env*))) (jolt-hash-map _o$8024 _o$8025 _o$8026 _o$8027 _o$8028 _o$8029 _o$8030 _o$8031))))))) analyze-letfn))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "field-head?" (letrec ((field-head? (lambda (nm) (let fnrec7909 ((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?))) + (def-var! "jolt.analyzer" "field-head?" (letrec ((field-head? (lambda (nm) (let fnrec8032 ((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?))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "def-meta-expr" (letrec ((def-meta-expr (lambda (ctx base env) (let fnrec7910 ((ctx ctx) (base base) (env env)) (if (jolt-pos? (jolt-count base)) (jolt-invoke (var-deref "jolt.ir" "map-node") (let* ((_a$7914 (var-deref "clojure.core" "mapv")) (_a$7915 (lambda (p) (let fnrec7911 ((p p)) (let* ((k (jolt-first p)) (v (jolt-invoke (var-deref "clojure.core" "second") p))) (let* ((_o$7912 (jolt-invoke (var-deref "jolt.ir" "const") k)) (_o$7913 (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$7912 _o$7913)))))) (_a$7916 (jolt-seq base))) (jolt-invoke _a$7914 _a$7915 _a$7916))) jolt-nil))))) def-meta-expr))) + (def-var! "jolt.analyzer" "def-meta-expr" (letrec ((def-meta-expr (lambda (ctx base env) (let fnrec8033 ((ctx ctx) (base base) (env env)) (if (jolt-pos? (jolt-count base)) (jolt-invoke (var-deref "jolt.ir" "map-node") (let* ((_a$8037 (var-deref "clojure.core" "mapv")) (_a$8038 (lambda (p) (let fnrec8034 ((p p)) (let* ((k (jolt-first p)) (v (jolt-invoke (var-deref "clojure.core" "second") p))) (let* ((_o$8035 (jolt-invoke (var-deref "jolt.ir" "const") k)) (_o$8036 (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$8035 _o$8036)))))) (_a$8039 (jolt-seq base))) (jolt-invoke _a$8037 _a$8038 _a$8039))) jolt-nil))))) def-meta-expr))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze-def" (letrec ((analyze-def (lambda (ctx items env) (let fnrec7917 ((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$7918 (keyword #f "op")) (_o$7919 (keyword #f "def")) (_o$7920 (keyword #f "ns")) (_o$7921 cur) (_o$7922 (keyword #f "name")) (_o$7923 nm) (_o$7924 (keyword #f "no-init")) (_o$7925 #t)) (jolt-hash-map _o$7918 _o$7919 _o$7920 _o$7921 _o$7922 _o$7923 _o$7924 _o$7925)))) (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$7926 (var-deref "jolt.analyzer" "with-ret-nhint")) (_a$7927 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx val-form env)) (_a$7928 (jolt-invoke (var-deref "jolt.analyzer" "tag->nkind") tag))) (jolt-invoke _a$7926 _a$7927 _a$7928)) 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))) + (def-var! "jolt.analyzer" "analyze-def" (letrec ((analyze-def (lambda (ctx items env) (let fnrec8040 ((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$8041 (keyword #f "op")) (_o$8042 (keyword #f "def")) (_o$8043 (keyword #f "ns")) (_o$8044 cur) (_o$8045 (keyword #f "name")) (_o$8046 nm) (_o$8047 (keyword #f "no-init")) (_o$8048 #t)) (jolt-hash-map _o$8041 _o$8042 _o$8043 _o$8044 _o$8045 _o$8046 _o$8047 _o$8048)))) (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$8049 (var-deref "jolt.analyzer" "with-ret-nhint")) (_a$8050 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx val-form env)) (_a$8051 (jolt-invoke (var-deref "jolt.analyzer" "tag->nkind") tag))) (jolt-invoke _a$8049 _a$8050 _a$8051)) 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))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze-set!" (letrec ((analyze-set! (lambda (ctx items env) (let fnrec7929 ((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$7930 (keyword #f "op")) (_o$7931 (keyword #f "set-field")) (_o$7932 (keyword #f "obj")) (_o$7933 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth ti 1) env)) (_o$7934 (keyword #f "field")) (_o$7935 (jolt-invoke (var-deref "clojure.core" "subs") thead 2)) (_o$7936 (keyword #f "val")) (_o$7937 val-node)) (jolt-hash-map _o$7930 _o$7931 _o$7932 _o$7933 _o$7934 _o$7935 _o$7936 _o$7937)) (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$7941 (var-deref "jolt.ir" "invoke")) (_a$7942 (jolt-invoke (var-deref "jolt.ir" "var-ref") "jolt.host" "set-static-field!")) (_a$7943 (let* ((_o$7938 (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$7939 (jolt-invoke (var-deref "jolt.ir" "const") (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth ti 2)))) (_o$7940 val-node)) (jolt-vector _o$7938 _o$7939 _o$7940)))) (jolt-invoke _a$7941 _a$7942 _a$7943)) (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$7947 (keyword #f "op")) (_o$7948 (keyword #f "set-var")) (_o$7949 (keyword #f "the-var")) (_o$7950 (let* ((_a$7944 (var-deref "jolt.ir" "the-var")) (_a$7945 (jolt-get r (keyword #f "ns"))) (_a$7946 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$7944 _a$7945 _a$7946))) (_o$7951 (keyword #f "val")) (_o$7952 val-node)) (jolt-hash-map _o$7947 _o$7948 _o$7949 _o$7950 _o$7951 _o$7952))))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "set! of an unsupported target") jolt-nil))))))))) analyze-set!))) + (def-var! "jolt.analyzer" "analyze-set!" (letrec ((analyze-set! (lambda (ctx items env) (let fnrec8052 ((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$8053 (keyword #f "op")) (_o$8054 (keyword #f "set-field")) (_o$8055 (keyword #f "obj")) (_o$8056 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth ti 1) env)) (_o$8057 (keyword #f "field")) (_o$8058 (jolt-invoke (var-deref "clojure.core" "subs") thead 2)) (_o$8059 (keyword #f "val")) (_o$8060 val-node)) (jolt-hash-map _o$8053 _o$8054 _o$8055 _o$8056 _o$8057 _o$8058 _o$8059 _o$8060)) (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$8064 (var-deref "jolt.ir" "invoke")) (_a$8065 (jolt-invoke (var-deref "jolt.ir" "var-ref") "jolt.host" "set-static-field!")) (_a$8066 (let* ((_o$8061 (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$8062 (jolt-invoke (var-deref "jolt.ir" "const") (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth ti 2)))) (_o$8063 val-node)) (jolt-vector _o$8061 _o$8062 _o$8063)))) (jolt-invoke _a$8064 _a$8065 _a$8066)) (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$8070 (keyword #f "op")) (_o$8071 (keyword #f "set-var")) (_o$8072 (keyword #f "the-var")) (_o$8073 (let* ((_a$8067 (var-deref "jolt.ir" "the-var")) (_a$8068 (jolt-get r (keyword #f "ns"))) (_a$8069 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8067 _a$8068 _a$8069))) (_o$8074 (keyword #f "val")) (_o$8075 val-node)) (jolt-hash-map _o$8070 _o$8071 _o$8072 _o$8073 _o$8074 _o$8075))))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "set! of an unsupported target") jolt-nil))))))))) analyze-set!))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze-special" (letrec ((analyze-special (lambda (ctx op items env) (let fnrec7953 ((ctx ctx) (op op) (items items) (env env)) (let* ((G__145 op)) (if (jolt= G__145 "quote") (jolt-invoke (var-deref "jolt.ir" "quote-node") (jolt-invoke (var-deref "clojure.core" "second") items)) (if (jolt= G__145 "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$7954 (var-deref "jolt.ir" "if-node")) (_a$7955 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_a$7956 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 2) env)) (_a$7957 (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$7954 _a$7955 _a$7956 _a$7957))) (if (jolt= G__145 "do") (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-rest items) env) (if (jolt= G__145 "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__145 "def") (jolt-invoke (var-deref "jolt.analyzer" "analyze-def") ctx items env) (if (jolt= G__145 "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$7962 (var-deref "jolt.ir" "let-node")) (_a$7963 (jolt-first r)) (_a$7964 (let* ((_a$7958 (var-deref "jolt.analyzer" "analyze-seq")) (_a$7959 ctx) (_a$7960 (jolt-drop 2 items)) (_a$7961 (jolt-invoke (var-deref "clojure.core" "second") r))) (jolt-invoke _a$7958 _a$7959 _a$7960 _a$7961)))) (jolt-invoke _a$7962 _a$7963 _a$7964))) (if (jolt= G__145 "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$7965 (keyword #f "op")) (_o$7966 (keyword #f "loop")) (_o$7967 (keyword #f "recur-name")) (_o$7968 rname) (_o$7969 (keyword #f "bindings")) (_o$7970 (jolt-first r)) (_o$7971 (keyword #f "body")) (_o$7972 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env**))) (jolt-hash-map _o$7965 _o$7966 _o$7967 _o$7968 _o$7969 _o$7970 _o$7971 _o$7972))) (if (jolt= G__145 "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$7977 (keyword #f "op")) (_o$7978 (keyword #f "recur")) (_o$7979 (keyword #f "recur-name")) (_o$7980 rt) (_o$7981 (keyword #f "args")) (_o$7982 (let* ((_a$7974 (var-deref "clojure.core" "mapv")) (_a$7975 (lambda (p__93_) (let fnrec7973 ((p__93_ p__93_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__93_ env)))) (_a$7976 (jolt-rest items))) (jolt-invoke _a$7974 _a$7975 _a$7976)))) (jolt-hash-map _o$7977 _o$7978 _o$7979 _o$7980 _o$7981 _o$7982)))) (if (jolt= G__145 "try") (jolt-invoke (var-deref "jolt.analyzer" "analyze-try") ctx items env) (if (jolt= G__145 "letfn") (jolt-invoke (var-deref "jolt.analyzer" "analyze-letfn") ctx items env) (if (jolt= G__145 "fn*") (jolt-invoke (var-deref "jolt.analyzer" "analyze-fn") ctx items env) (if (jolt= G__145 "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__145 "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$7983 (var-deref "jolt.ir" "the-var")) (_a$7984 (jolt-get r (keyword #f "ns"))) (_a$7985 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$7983 _a$7984 _a$7985)) (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__145 "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$7986 (keyword #f "op")) (_o$7987 (keyword #f "defmacro")) (_o$7988 (keyword #f "ns")) (_o$7989 cur) (_o$7990 (keyword #f "name")) (_o$7991 nm) (_o$7992 (keyword #f "fn")) (_o$7993 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx fn-form env))) (jolt-hash-map _o$7986 _o$7987 _o$7988 _o$7989 _o$7990 _o$7991 _o$7992 _o$7993)))) (if (jolt= G__145 "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))) + (def-var! "jolt.analyzer" "analyze-special" (letrec ((analyze-special (lambda (ctx op items env) (let fnrec8076 ((ctx ctx) (op op) (items items) (env env)) (let* ((G__145 op)) (if (jolt= G__145 "quote") (jolt-invoke (var-deref "jolt.ir" "quote-node") (jolt-invoke (var-deref "clojure.core" "second") items)) (if (jolt= G__145 "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$8077 (var-deref "jolt.ir" "if-node")) (_a$8078 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_a$8079 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 2) env)) (_a$8080 (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$8077 _a$8078 _a$8079 _a$8080))) (if (jolt= G__145 "do") (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-rest items) env) (if (jolt= G__145 "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__145 "def") (jolt-invoke (var-deref "jolt.analyzer" "analyze-def") ctx items env) (if (jolt= G__145 "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$8085 (var-deref "jolt.ir" "let-node")) (_a$8086 (jolt-first r)) (_a$8087 (let* ((_a$8081 (var-deref "jolt.analyzer" "analyze-seq")) (_a$8082 ctx) (_a$8083 (jolt-drop 2 items)) (_a$8084 (jolt-invoke (var-deref "clojure.core" "second") r))) (jolt-invoke _a$8081 _a$8082 _a$8083 _a$8084)))) (jolt-invoke _a$8085 _a$8086 _a$8087))) (if (jolt= G__145 "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$8088 (keyword #f "op")) (_o$8089 (keyword #f "loop")) (_o$8090 (keyword #f "recur-name")) (_o$8091 rname) (_o$8092 (keyword #f "bindings")) (_o$8093 (jolt-first r)) (_o$8094 (keyword #f "body")) (_o$8095 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env**))) (jolt-hash-map _o$8088 _o$8089 _o$8090 _o$8091 _o$8092 _o$8093 _o$8094 _o$8095))) (if (jolt= G__145 "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$8100 (keyword #f "op")) (_o$8101 (keyword #f "recur")) (_o$8102 (keyword #f "recur-name")) (_o$8103 rt) (_o$8104 (keyword #f "args")) (_o$8105 (let* ((_a$8097 (var-deref "clojure.core" "mapv")) (_a$8098 (lambda (p__93_) (let fnrec8096 ((p__93_ p__93_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__93_ env)))) (_a$8099 (jolt-rest items))) (jolt-invoke _a$8097 _a$8098 _a$8099)))) (jolt-hash-map _o$8100 _o$8101 _o$8102 _o$8103 _o$8104 _o$8105)))) (if (jolt= G__145 "try") (jolt-invoke (var-deref "jolt.analyzer" "analyze-try") ctx items env) (if (jolt= G__145 "letfn") (jolt-invoke (var-deref "jolt.analyzer" "analyze-letfn") ctx items env) (if (jolt= G__145 "fn*") (jolt-invoke (var-deref "jolt.analyzer" "analyze-fn") ctx items env) (if (jolt= G__145 "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__145 "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$8106 (var-deref "jolt.ir" "the-var")) (_a$8107 (jolt-get r (keyword #f "ns"))) (_a$8108 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8106 _a$8107 _a$8108)) (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__145 "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$8109 (keyword #f "op")) (_o$8110 (keyword #f "defmacro")) (_o$8111 (keyword #f "ns")) (_o$8112 cur) (_o$8113 (keyword #f "name")) (_o$8114 nm) (_o$8115 (keyword #f "fn")) (_o$8116 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx fn-form env))) (jolt-hash-map _o$8109 _o$8110 _o$8111 _o$8112 _o$8113 _o$8114 _o$8115 _o$8116)))) (if (jolt= G__145 "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))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "method-head?" (letrec ((method-head? (lambda (nm) (let fnrec7994 ((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?))) + (def-var! "jolt.analyzer" "method-head?" (letrec ((method-head? (lambda (nm) (let fnrec8117 ((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?))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze-host-call" (letrec ((analyze-host-call (lambda (ctx hname items env) (let fnrec7995 ((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$8000 (keyword #f "op")) (_o$8001 (keyword #f "host-call")) (_o$8002 (keyword #f "method")) (_o$8003 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$8004 (keyword #f "target")) (_o$8005 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$8006 (keyword #f "args")) (_o$8007 (let* ((_a$7997 (var-deref "clojure.core" "mapv")) (_a$7998 (lambda (p__94_) (let fnrec7996 ((p__94_ p__94_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__94_ env)))) (_a$7999 (jolt-drop 2 items))) (jolt-invoke _a$7997 _a$7998 _a$7999)))) (jolt-hash-map _o$8000 _o$8001 _o$8002 _o$8003 _o$8004 _o$8005 _o$8006 _o$8007))))))) analyze-host-call))) + (def-var! "jolt.analyzer" "analyze-host-call" (letrec ((analyze-host-call (lambda (ctx hname items env) (let fnrec8118 ((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$8123 (keyword #f "op")) (_o$8124 (keyword #f "host-call")) (_o$8125 (keyword #f "method")) (_o$8126 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$8127 (keyword #f "target")) (_o$8128 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$8129 (keyword #f "args")) (_o$8130 (let* ((_a$8120 (var-deref "clojure.core" "mapv")) (_a$8121 (lambda (p__94_) (let fnrec8119 ((p__94_ p__94_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__94_ env)))) (_a$8122 (jolt-drop 2 items))) (jolt-invoke _a$8120 _a$8121 _a$8122)))) (jolt-hash-map _o$8123 _o$8124 _o$8125 _o$8126 _o$8127 _o$8128 _o$8129 _o$8130))))))) analyze-host-call))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "ctor-head?" (letrec ((ctor-head? (lambda (nm) (let fnrec8008 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 1))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "." (let* ((_a$8009 (var-deref "clojure.core" "subs")) (_a$8010 nm) (_a$8011 (jolt-dec (jolt-count nm))) (_a$8012 (jolt-count nm))) (jolt-invoke _a$8009 _a$8010 _a$8011 _a$8012))))) (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?))) + (def-var! "jolt.analyzer" "ctor-head?" (letrec ((ctor-head? (lambda (nm) (let fnrec8131 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 1))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "." (let* ((_a$8132 (var-deref "clojure.core" "subs")) (_a$8133 nm) (_a$8134 (jolt-dec (jolt-count nm))) (_a$8135 (jolt-count nm))) (jolt-invoke _a$8132 _a$8133 _a$8134 _a$8135))))) (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?))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze-ctor" (letrec ((analyze-ctor (lambda (ctx class args env) (let fnrec8013 ((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__95_) (let fnrec8014 ((p__95_ p__95_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__95_ env))) args)))))) analyze-ctor))) + (def-var! "jolt.analyzer" "analyze-ctor" (letrec ((analyze-ctor (lambda (ctx class args env) (let fnrec8136 ((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__95_) (let fnrec8137 ((p__95_ p__95_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__95_ env))) args)))))) analyze-ctor))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze-ffi-fn" (letrec ((analyze-ffi-fn (lambda (ctx items env) (let fnrec8015 ((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$8016 (keyword #f "op")) (_o$8017 (keyword #f "ffi-fn")) (_o$8018 (keyword #f "csym")) (_o$8019 (jolt-nth items 1)) (_o$8020 (keyword #f "argtypes")) (_o$8021 (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$8022 (keyword #f "rettype")) (_o$8023 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$8024 (keyword #f "blocking")) (_o$8025 (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$8016 _o$8017 _o$8018 _o$8019 _o$8020 _o$8021 _o$8022 _o$8023 _o$8024 _o$8025))))))) analyze-ffi-fn))) + (def-var! "jolt.analyzer" "analyze-ffi-fn" (letrec ((analyze-ffi-fn (lambda (ctx items env) (let fnrec8138 ((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$8139 (keyword #f "op")) (_o$8140 (keyword #f "ffi-fn")) (_o$8141 (keyword #f "csym")) (_o$8142 (jolt-nth items 1)) (_o$8143 (keyword #f "argtypes")) (_o$8144 (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$8145 (keyword #f "rettype")) (_o$8146 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$8147 (keyword #f "blocking")) (_o$8148 (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$8139 _o$8140 _o$8141 _o$8142 _o$8143 _o$8144 _o$8145 _o$8146 _o$8147 _o$8148))))))) analyze-ffi-fn))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze-ffi-callable" (letrec ((analyze-ffi-callable (lambda (ctx items env) (let fnrec8026 ((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$8027 (keyword #f "op")) (_o$8028 (keyword #f "ffi-callable")) (_o$8029 (keyword #f "fn")) (_o$8030 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$8031 (keyword #f "argtypes")) (_o$8032 (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$8033 (keyword #f "rettype")) (_o$8034 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$8035 (keyword #f "collect-safe")) (_o$8036 (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$8027 _o$8028 _o$8029 _o$8030 _o$8031 _o$8032 _o$8033 _o$8034 _o$8035 _o$8036))))))) analyze-ffi-callable))) + (def-var! "jolt.analyzer" "analyze-ffi-callable" (letrec ((analyze-ffi-callable (lambda (ctx items env) (let fnrec8149 ((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$8150 (keyword #f "op")) (_o$8151 (keyword #f "ffi-callable")) (_o$8152 (keyword #f "fn")) (_o$8153 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$8154 (keyword #f "argtypes")) (_o$8155 (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$8156 (keyword #f "rettype")) (_o$8157 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$8158 (keyword #f "collect-safe")) (_o$8159 (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$8150 _o$8151 _o$8152 _o$8153 _o$8154 _o$8155 _o$8156 _o$8157 _o$8158 _o$8159))))))) analyze-ffi-callable))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze-dot" (letrec ((analyze-dot (lambda (ctx items env) (let fnrec8037 ((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* ((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$8042 (var-deref "jolt.ir" "invoke")) (_a$8043 (jolt-invoke (var-deref "jolt.ir" "host-static") class-target (jolt-invoke (var-deref "jolt.host" "form-sym-name") member))) (_a$8044 (let* ((_a$8039 (var-deref "clojure.core" "mapv")) (_a$8040 (lambda (p__96_) (let fnrec8038 ((p__96_ p__96_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__96_ env)))) (_a$8041 (jolt-drop 3 items))) (jolt-invoke _a$8039 _a$8040 _a$8041)))) (jolt-invoke _a$8042 _a$8043 _a$8044)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") member)) (let* ((_o$8049 (keyword #f "op")) (_o$8050 (keyword #f "host-call")) (_o$8051 (keyword #f "method")) (_o$8052 (jolt-invoke (var-deref "jolt.host" "form-sym-name") member)) (_o$8053 (keyword #f "target")) (_o$8054 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx target env)) (_o$8055 (keyword #f "args")) (_o$8056 (let* ((_a$8046 (var-deref "clojure.core" "mapv")) (_a$8047 (lambda (p__97_) (let fnrec8045 ((p__97_ p__97_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__97_ env)))) (_a$8048 (jolt-drop 3 items))) (jolt-invoke _a$8046 _a$8047 _a$8048)))) (jolt-hash-map _o$8049 _o$8050 _o$8051 _o$8052 _o$8053 _o$8054 _o$8055 _o$8056)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-keyword?") member)) (let* ((_a$8057 (var-deref "jolt.ir" "invoke")) (_a$8058 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx member env)) (_a$8059 (jolt-vector (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)))) (jolt-invoke _a$8057 _a$8058 _a$8059)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "special form . (non-symbol member)") jolt-nil)))))))))) analyze-dot))) + (def-var! "jolt.analyzer" "analyze-dot" (letrec ((analyze-dot (lambda (ctx items env) (let fnrec8160 ((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* ((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$8165 (var-deref "jolt.ir" "invoke")) (_a$8166 (jolt-invoke (var-deref "jolt.ir" "host-static") class-target (jolt-invoke (var-deref "jolt.host" "form-sym-name") member))) (_a$8167 (let* ((_a$8162 (var-deref "clojure.core" "mapv")) (_a$8163 (lambda (p__96_) (let fnrec8161 ((p__96_ p__96_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__96_ env)))) (_a$8164 (jolt-drop 3 items))) (jolt-invoke _a$8162 _a$8163 _a$8164)))) (jolt-invoke _a$8165 _a$8166 _a$8167)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") member)) (let* ((_o$8172 (keyword #f "op")) (_o$8173 (keyword #f "host-call")) (_o$8174 (keyword #f "method")) (_o$8175 (jolt-invoke (var-deref "jolt.host" "form-sym-name") member)) (_o$8176 (keyword #f "target")) (_o$8177 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx target env)) (_o$8178 (keyword #f "args")) (_o$8179 (let* ((_a$8169 (var-deref "clojure.core" "mapv")) (_a$8170 (lambda (p__97_) (let fnrec8168 ((p__97_ p__97_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__97_ env)))) (_a$8171 (jolt-drop 3 items))) (jolt-invoke _a$8169 _a$8170 _a$8171)))) (jolt-hash-map _o$8172 _o$8173 _o$8174 _o$8175 _o$8176 _o$8177 _o$8178 _o$8179)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-keyword?") member)) (let* ((_a$8180 (var-deref "jolt.ir" "invoke")) (_a$8181 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx member env)) (_a$8182 (jolt-vector (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)))) (jolt-invoke _a$8180 _a$8181 _a$8182)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "special form . (non-symbol member)") jolt-nil)))))))))) analyze-dot))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze-field" (letrec ((analyze-field (lambda (ctx hname items env) (let fnrec8060 ((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$8061 (keyword #f "op")) (_o$8062 (keyword #f "host-call")) (_o$8063 (keyword #f "method")) (_o$8064 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$8065 (keyword #f "target")) (_o$8066 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$8067 (keyword #f "args")) (_o$8068 (jolt-vector))) (jolt-hash-map _o$8061 _o$8062 _o$8063 _o$8064 _o$8065 _o$8066 _o$8067 _o$8068))))))) analyze-field))) + (def-var! "jolt.analyzer" "analyze-field" (letrec ((analyze-field (lambda (ctx hname items env) (let fnrec8183 ((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$8184 (keyword #f "op")) (_o$8185 (keyword #f "host-call")) (_o$8186 (keyword #f "method")) (_o$8187 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$8188 (keyword #f "target")) (_o$8189 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$8190 (keyword #f "args")) (_o$8191 (jolt-vector))) (jolt-hash-map _o$8184 _o$8185 _o$8186 _o$8187 _o$8188 _o$8189 _o$8190 _o$8191))))))) analyze-field))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze-symbol" (letrec ((analyze-symbol (lambda (ctx form env) (let fnrec8069 ((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__146 (let* ((_a$8070 (var-deref "jolt.ir" "var-ref")) (_a$8071 (jolt-get r (keyword #f "ns"))) (_a$8072 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8070 _a$8071 _a$8072)))) (let* ((G__147 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__146 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__146))) G__147)) (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__148 (jolt-get r (keyword #f "kind")))) (if (jolt= G__148 (keyword #f "var")) (let* ((G__149 (let* ((_a$8073 (var-deref "jolt.ir" "var-ref")) (_a$8074 (jolt-get r (keyword #f "ns"))) (_a$8075 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8073 _a$8074 _a$8075)))) (let* ((G__150 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__149 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__149))) G__150)) (if (jolt= G__148 (keyword #f "host")) (jolt-invoke (var-deref "jolt.ir" "host-ref") (jolt-get r (keyword #f "name"))) (if (jolt= G__148 (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))) + (def-var! "jolt.analyzer" "analyze-symbol" (letrec ((analyze-symbol (lambda (ctx form env) (let fnrec8192 ((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__146 (let* ((_a$8193 (var-deref "jolt.ir" "var-ref")) (_a$8194 (jolt-get r (keyword #f "ns"))) (_a$8195 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8193 _a$8194 _a$8195)))) (let* ((G__147 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__146 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__146))) G__147)) (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__148 (jolt-get r (keyword #f "kind")))) (if (jolt= G__148 (keyword #f "var")) (let* ((G__149 (let* ((_a$8196 (var-deref "jolt.ir" "var-ref")) (_a$8197 (jolt-get r (keyword #f "ns"))) (_a$8198 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8196 _a$8197 _a$8198)))) (let* ((G__150 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__149 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__149))) G__150)) (if (jolt= G__148 (keyword #f "host")) (jolt-invoke (var-deref "jolt.ir" "host-ref") (jolt-get r (keyword #f "name"))) (if (jolt= G__148 (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))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze-list" (letrec ((analyze-list (lambda (ctx form env) (let fnrec8076 ((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)) (shadowed (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "local?") env hname) and__25__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-not shadowed))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-contains? (var-deref "jolt.analyzer" "handled") hname)))) (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) 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 hname)) (if (jolt-truthy? and__25__auto) (jolt-contains? (var-deref "jolt.analyzer" "handled") hname) and__25__auto))) (let* ((node (jolt-invoke (var-deref "jolt.analyzer" "analyze-special") ctx hname 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$8077 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$8078 ctx) (_a$8079 (jolt-invoke (var-deref "clojure.core" "subs") hname 0 (jolt-dec (jolt-count hname)))) (_a$8080 (jolt-rest items)) (_a$8081 env)) (jolt-invoke _a$8077 _a$8078 _a$8079 _a$8080 _a$8081)) (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$8082 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$8083 ctx) (_a$8084 (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth items 1))) (_a$8085 (jolt-drop 2 items)) (_a$8086 env)) (jolt-invoke _a$8082 _a$8083 _a$8084 _a$8085 _a$8086)) (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$8091 (var-deref "jolt.ir" "invoke")) (_a$8092 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx head env)) (_a$8093 (let* ((_a$8088 (var-deref "clojure.core" "mapv")) (_a$8089 (lambda (p__98_) (let fnrec8087 ((p__98_ p__98_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__98_ env)))) (_a$8090 (jolt-rest items))) (jolt-invoke _a$8088 _a$8089 _a$8090)))) (jolt-invoke _a$8091 _a$8092 _a$8093))) (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))) + (def-var! "jolt.analyzer" "analyze-list" (letrec ((analyze-list (lambda (ctx form env) (let fnrec8199 ((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)) (shadowed (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "local?") env hname) and__25__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-not shadowed))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-contains? (var-deref "jolt.analyzer" "handled") hname)))) (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) 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 hname)) (if (jolt-truthy? and__25__auto) (jolt-contains? (var-deref "jolt.analyzer" "handled") hname) and__25__auto))) (let* ((node (jolt-invoke (var-deref "jolt.analyzer" "analyze-special") ctx hname 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$8200 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$8201 ctx) (_a$8202 (jolt-invoke (var-deref "clojure.core" "subs") hname 0 (jolt-dec (jolt-count hname)))) (_a$8203 (jolt-rest items)) (_a$8204 env)) (jolt-invoke _a$8200 _a$8201 _a$8202 _a$8203 _a$8204)) (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$8205 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$8206 ctx) (_a$8207 (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth items 1))) (_a$8208 (jolt-drop 2 items)) (_a$8209 env)) (jolt-invoke _a$8205 _a$8206 _a$8207 _a$8208 _a$8209)) (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$8214 (var-deref "jolt.ir" "invoke")) (_a$8215 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx head env)) (_a$8216 (let* ((_a$8211 (var-deref "clojure.core" "mapv")) (_a$8212 (lambda (p__98_) (let fnrec8210 ((p__98_ p__98_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__98_ env)))) (_a$8213 (jolt-rest items))) (jolt-invoke _a$8211 _a$8212 _a$8213)))) (jolt-invoke _a$8214 _a$8215 _a$8216))) (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))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "with-coll-meta" (letrec ((with-coll-meta (lambda (ctx form env node) (let fnrec8094 ((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$8097 (var-deref "jolt.ir" "invoke")) (_a$8098 (jolt-invoke (var-deref "jolt.ir" "var-ref") "clojure.core" "with-meta")) (_a$8099 (let* ((_o$8095 node) (_o$8096 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx m env))) (jolt-vector _o$8095 _o$8096)))) (jolt-invoke _a$8097 _a$8098 _a$8099)))))))) with-coll-meta))) + (def-var! "jolt.analyzer" "with-coll-meta" (letrec ((with-coll-meta (lambda (ctx form env node) (let fnrec8217 ((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$8220 (var-deref "jolt.ir" "invoke")) (_a$8221 (jolt-invoke (var-deref "jolt.ir" "var-ref") "clojure.core" "with-meta")) (_a$8222 (let* ((_o$8218 node) (_o$8219 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx m env))) (jolt-vector _o$8218 _o$8219)))) (jolt-invoke _a$8220 _a$8221 _a$8222)))))))) with-coll-meta))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze" (letrec ((analyze (case-lambda ((ctx form) (let fnrec8100 ((ctx ctx) (form form)) (analyze ctx form (jolt-invoke (var-deref "jolt.analyzer" "empty-env"))))) ((ctx form env) (let fnrec8101 ((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$8103 (var-deref "clojure.core" "mapv")) (_a$8104 (lambda (p__99_) (let fnrec8102 ((p__99_ p__99_)) (analyze ctx p__99_ env)))) (_a$8105 (jolt-invoke (var-deref "jolt.host" "form-vec-items") form))) (jolt-invoke _a$8103 _a$8104 _a$8105)))) (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$8109 (var-deref "clojure.core" "mapv")) (_a$8110 (lambda (p) (let fnrec8106 ((p p)) (let* ((_o$8107 (analyze ctx (jolt-first p) env)) (_o$8108 (analyze ctx (jolt-invoke (var-deref "clojure.core" "second") p) env))) (jolt-vector _o$8107 _o$8108))))) (_a$8111 (jolt-invoke (var-deref "jolt.host" "form-map-pairs") form))) (jolt-invoke _a$8109 _a$8110 _a$8111)))) (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$8113 (var-deref "clojure.core" "mapv")) (_a$8114 (lambda (p__100_) (let fnrec8112 ((p__100_ p__100_)) (analyze ctx p__100_ env)))) (_a$8115 (jolt-invoke (var-deref "jolt.host" "form-set-items") form))) (jolt-invoke _a$8113 _a$8114 _a$8115)))) (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$8116 (keyword #f "op")) (_o$8117 (keyword #f "regex")) (_o$8118 (keyword #f "source")) (_o$8119 (jolt-invoke (var-deref "jolt.host" "form-regex-source") form))) (jolt-hash-map _o$8116 _o$8117 _o$8118 _o$8119)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-inst?") form)) (let* ((_o$8120 (keyword #f "op")) (_o$8121 (keyword #f "inst")) (_o$8122 (keyword #f "source")) (_o$8123 (jolt-invoke (var-deref "jolt.host" "form-inst-source") form))) (jolt-hash-map _o$8120 _o$8121 _o$8122 _o$8123)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-uuid?") form)) (let* ((_o$8124 (keyword #f "op")) (_o$8125 (keyword #f "uuid")) (_o$8126 (keyword #f "source")) (_o$8127 (jolt-invoke (var-deref "jolt.host" "form-uuid-source") form))) (jolt-hash-map _o$8124 _o$8125 _o$8126 _o$8127)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-bigdec?") form)) (let* ((_o$8128 (keyword #f "op")) (_o$8129 (keyword #f "bigdec")) (_o$8130 (keyword #f "source")) (_o$8131 (jolt-invoke (var-deref "jolt.host" "form-bigdec-source") form))) (jolt-hash-map _o$8128 _o$8129 _o$8130 _o$8131)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-ns-value?") form)) (let* ((_o$8132 (keyword #f "op")) (_o$8133 (keyword #f "the-ns")) (_o$8134 (keyword #f "name")) (_o$8135 (jolt-invoke (var-deref "jolt.host" "form-ns-value-name") form))) (jolt-hash-map _o$8132 _o$8133 _o$8134 _o$8135)) (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 fnrec8223 ((ctx ctx) (form form)) (analyze ctx form (jolt-invoke (var-deref "jolt.analyzer" "empty-env"))))) ((ctx form env) (let fnrec8224 ((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$8226 (var-deref "clojure.core" "mapv")) (_a$8227 (lambda (p__99_) (let fnrec8225 ((p__99_ p__99_)) (analyze ctx p__99_ env)))) (_a$8228 (jolt-invoke (var-deref "jolt.host" "form-vec-items") form))) (jolt-invoke _a$8226 _a$8227 _a$8228)))) (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$8232 (var-deref "clojure.core" "mapv")) (_a$8233 (lambda (p) (let fnrec8229 ((p p)) (let* ((_o$8230 (analyze ctx (jolt-first p) env)) (_o$8231 (analyze ctx (jolt-invoke (var-deref "clojure.core" "second") p) env))) (jolt-vector _o$8230 _o$8231))))) (_a$8234 (jolt-invoke (var-deref "jolt.host" "form-map-pairs") form))) (jolt-invoke _a$8232 _a$8233 _a$8234)))) (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$8236 (var-deref "clojure.core" "mapv")) (_a$8237 (lambda (p__100_) (let fnrec8235 ((p__100_ p__100_)) (analyze ctx p__100_ env)))) (_a$8238 (jolt-invoke (var-deref "jolt.host" "form-set-items") form))) (jolt-invoke _a$8236 _a$8237 _a$8238)))) (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$8239 (keyword #f "op")) (_o$8240 (keyword #f "regex")) (_o$8241 (keyword #f "source")) (_o$8242 (jolt-invoke (var-deref "jolt.host" "form-regex-source") form))) (jolt-hash-map _o$8239 _o$8240 _o$8241 _o$8242)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-inst?") form)) (let* ((_o$8243 (keyword #f "op")) (_o$8244 (keyword #f "inst")) (_o$8245 (keyword #f "source")) (_o$8246 (jolt-invoke (var-deref "jolt.host" "form-inst-source") form))) (jolt-hash-map _o$8243 _o$8244 _o$8245 _o$8246)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-uuid?") form)) (let* ((_o$8247 (keyword #f "op")) (_o$8248 (keyword #f "uuid")) (_o$8249 (keyword #f "source")) (_o$8250 (jolt-invoke (var-deref "jolt.host" "form-uuid-source") form))) (jolt-hash-map _o$8247 _o$8248 _o$8249 _o$8250)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-bigdec?") form)) (let* ((_o$8251 (keyword #f "op")) (_o$8252 (keyword #f "bigdec")) (_o$8253 (keyword #f "source")) (_o$8254 (jolt-invoke (var-deref "jolt.host" "form-bigdec-source") form))) (jolt-hash-map _o$8251 _o$8252 _o$8253 _o$8254)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-ns-value?") form)) (let* ((_o$8255 (keyword #f "op")) (_o$8256 (keyword #f "the-ns")) (_o$8257 (keyword #f "name")) (_o$8258 (jolt-invoke (var-deref "jolt.host" "form-ns-value-name") form))) (jolt-hash-map _o$8255 _o$8256 _o$8257 _o$8258)) (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$6517 "+") (_o$6518 "+") (_o$6519 "-") (_o$6520 "-") (_o$6521 "*") (_o$6522 "*") (_o$6523 "/") (_o$6524 "/") (_o$6525 "<") (_o$6526 "<") (_o$6527 ">") (_o$6528 ">") (_o$6529 "<=") (_o$6530 "<=") (_o$6531 ">=") (_o$6532 ">=") (_o$6533 "=") (_o$6534 "jolt=") (_o$6535 "inc") (_o$6536 "jolt-inc") (_o$6537 "dec") (_o$6538 "jolt-dec") (_o$6539 "not") (_o$6540 "jolt-not") (_o$6541 "min") (_o$6542 "min") (_o$6543 "max") (_o$6544 "max") (_o$6545 "mod") (_o$6546 "modulo") (_o$6547 "rem") (_o$6548 "remainder") (_o$6549 "quot") (_o$6550 "quotient") (_o$6551 "vector") (_o$6552 "jolt-vector") (_o$6553 "hash-map") (_o$6554 "jolt-hash-map") (_o$6555 "hash-set") (_o$6556 "jolt-hash-set") (_o$6557 "conj") (_o$6558 "jolt-conj") (_o$6559 "get") (_o$6560 "jolt-get") (_o$6561 "nth") (_o$6562 "jolt-nth") (_o$6563 "count") (_o$6564 "jolt-count") (_o$6565 "assoc") (_o$6566 "jolt-assoc") (_o$6567 "dissoc") (_o$6568 "jolt-dissoc") (_o$6569 "contains?") (_o$6570 "jolt-contains?") (_o$6571 "empty?") (_o$6572 "jolt-empty?") (_o$6573 "peek") (_o$6574 "jolt-peek") (_o$6575 "pop") (_o$6576 "jolt-pop") (_o$6577 "first") (_o$6578 "jolt-first") (_o$6579 "rest") (_o$6580 "jolt-rest") (_o$6581 "next") (_o$6582 "jolt-next") (_o$6583 "seq") (_o$6584 "jolt-seq") (_o$6585 "cons") (_o$6586 "jolt-cons") (_o$6587 "list") (_o$6588 "jolt-list") (_o$6589 "reverse") (_o$6590 "jolt-reverse") (_o$6591 "last") (_o$6592 "jolt-last") (_o$6593 "map") (_o$6594 "jolt-map") (_o$6595 "filter") (_o$6596 "jolt-filter") (_o$6597 "remove") (_o$6598 "jolt-remove") (_o$6599 "reduce") (_o$6600 "jolt-reduce") (_o$6601 "into") (_o$6602 "jolt-into") (_o$6603 "concat") (_o$6604 "jolt-concat") (_o$6605 "apply") (_o$6606 "jolt-apply") (_o$6607 "range") (_o$6608 "jolt-range") (_o$6609 "take") (_o$6610 "jolt-take") (_o$6611 "drop") (_o$6612 "jolt-drop") (_o$6613 "keys") (_o$6614 "jolt-keys") (_o$6615 "vals") (_o$6616 "jolt-vals") (_o$6617 "even?") (_o$6618 "jolt-even?") (_o$6619 "odd?") (_o$6620 "jolt-odd?") (_o$6621 "pos?") (_o$6622 "jolt-pos?") (_o$6623 "neg?") (_o$6624 "jolt-neg?") (_o$6625 "zero?") (_o$6626 "jolt-zero?") (_o$6627 "identity") (_o$6628 "jolt-identity") (_o$6629 "nil?") (_o$6630 "jolt-nil?") (_o$6631 "some?") (_o$6632 "jolt-some?") (_o$6633 "ex-info") (_o$6634 "jolt-ex-info") (_o$6635 "protocol-dispatch1") (_o$6636 "protocol-dispatch1") (_o$6637 "protocol-dispatch2") (_o$6638 "protocol-dispatch2") (_o$6639 "protocol-dispatch3") (_o$6640 "protocol-dispatch3")) (jolt-hash-map _o$6517 _o$6518 _o$6519 _o$6520 _o$6521 _o$6522 _o$6523 _o$6524 _o$6525 _o$6526 _o$6527 _o$6528 _o$6529 _o$6530 _o$6531 _o$6532 _o$6533 _o$6534 _o$6535 _o$6536 _o$6537 _o$6538 _o$6539 _o$6540 _o$6541 _o$6542 _o$6543 _o$6544 _o$6545 _o$6546 _o$6547 _o$6548 _o$6549 _o$6550 _o$6551 _o$6552 _o$6553 _o$6554 _o$6555 _o$6556 _o$6557 _o$6558 _o$6559 _o$6560 _o$6561 _o$6562 _o$6563 _o$6564 _o$6565 _o$6566 _o$6567 _o$6568 _o$6569 _o$6570 _o$6571 _o$6572 _o$6573 _o$6574 _o$6575 _o$6576 _o$6577 _o$6578 _o$6579 _o$6580 _o$6581 _o$6582 _o$6583 _o$6584 _o$6585 _o$6586 _o$6587 _o$6588 _o$6589 _o$6590 _o$6591 _o$6592 _o$6593 _o$6594 _o$6595 _o$6596 _o$6597 _o$6598 _o$6599 _o$6600 _o$6601 _o$6602 _o$6603 _o$6604 _o$6605 _o$6606 _o$6607 _o$6608 _o$6609 _o$6610 _o$6611 _o$6612 _o$6613 _o$6614 _o$6615 _o$6616 _o$6617 _o$6618 _o$6619 _o$6620 _o$6621 _o$6622 _o$6623 _o$6624 _o$6625 _o$6626 _o$6627 _o$6628 _o$6629 _o$6630 _o$6631 _o$6632 _o$6633 _o$6634 _o$6635 _o$6636 _o$6637 _o$6638 _o$6639 _o$6640)) (let* ((_o$6641 (keyword #f "private")) (_o$6642 #t)) (jolt-hash-map _o$6641 _o$6642)))) + (def-var-with-meta! "jolt.backend-scheme" "native-ops" (let* ((_o$6640 "+") (_o$6641 "+") (_o$6642 "-") (_o$6643 "-") (_o$6644 "*") (_o$6645 "*") (_o$6646 "/") (_o$6647 "/") (_o$6648 "<") (_o$6649 "<") (_o$6650 ">") (_o$6651 ">") (_o$6652 "<=") (_o$6653 "<=") (_o$6654 ">=") (_o$6655 ">=") (_o$6656 "=") (_o$6657 "jolt=") (_o$6658 "inc") (_o$6659 "jolt-inc") (_o$6660 "dec") (_o$6661 "jolt-dec") (_o$6662 "not") (_o$6663 "jolt-not") (_o$6664 "min") (_o$6665 "min") (_o$6666 "max") (_o$6667 "max") (_o$6668 "mod") (_o$6669 "modulo") (_o$6670 "rem") (_o$6671 "remainder") (_o$6672 "quot") (_o$6673 "quotient") (_o$6674 "vector") (_o$6675 "jolt-vector") (_o$6676 "hash-map") (_o$6677 "jolt-hash-map") (_o$6678 "hash-set") (_o$6679 "jolt-hash-set") (_o$6680 "conj") (_o$6681 "jolt-conj") (_o$6682 "get") (_o$6683 "jolt-get") (_o$6684 "nth") (_o$6685 "jolt-nth") (_o$6686 "count") (_o$6687 "jolt-count") (_o$6688 "assoc") (_o$6689 "jolt-assoc") (_o$6690 "dissoc") (_o$6691 "jolt-dissoc") (_o$6692 "contains?") (_o$6693 "jolt-contains?") (_o$6694 "empty?") (_o$6695 "jolt-empty?") (_o$6696 "peek") (_o$6697 "jolt-peek") (_o$6698 "pop") (_o$6699 "jolt-pop") (_o$6700 "first") (_o$6701 "jolt-first") (_o$6702 "rest") (_o$6703 "jolt-rest") (_o$6704 "next") (_o$6705 "jolt-next") (_o$6706 "seq") (_o$6707 "jolt-seq") (_o$6708 "cons") (_o$6709 "jolt-cons") (_o$6710 "list") (_o$6711 "jolt-list") (_o$6712 "reverse") (_o$6713 "jolt-reverse") (_o$6714 "last") (_o$6715 "jolt-last") (_o$6716 "map") (_o$6717 "jolt-map") (_o$6718 "filter") (_o$6719 "jolt-filter") (_o$6720 "remove") (_o$6721 "jolt-remove") (_o$6722 "reduce") (_o$6723 "jolt-reduce") (_o$6724 "into") (_o$6725 "jolt-into") (_o$6726 "concat") (_o$6727 "jolt-concat") (_o$6728 "apply") (_o$6729 "jolt-apply") (_o$6730 "range") (_o$6731 "jolt-range") (_o$6732 "take") (_o$6733 "jolt-take") (_o$6734 "drop") (_o$6735 "jolt-drop") (_o$6736 "keys") (_o$6737 "jolt-keys") (_o$6738 "vals") (_o$6739 "jolt-vals") (_o$6740 "even?") (_o$6741 "jolt-even?") (_o$6742 "odd?") (_o$6743 "jolt-odd?") (_o$6744 "pos?") (_o$6745 "jolt-pos?") (_o$6746 "neg?") (_o$6747 "jolt-neg?") (_o$6748 "zero?") (_o$6749 "jolt-zero?") (_o$6750 "identity") (_o$6751 "jolt-identity") (_o$6752 "nil?") (_o$6753 "jolt-nil?") (_o$6754 "some?") (_o$6755 "jolt-some?") (_o$6756 "ex-info") (_o$6757 "jolt-ex-info") (_o$6758 "protocol-dispatch1") (_o$6759 "protocol-dispatch1") (_o$6760 "protocol-dispatch2") (_o$6761 "protocol-dispatch2") (_o$6762 "protocol-dispatch3") (_o$6763 "protocol-dispatch3")) (jolt-hash-map _o$6640 _o$6641 _o$6642 _o$6643 _o$6644 _o$6645 _o$6646 _o$6647 _o$6648 _o$6649 _o$6650 _o$6651 _o$6652 _o$6653 _o$6654 _o$6655 _o$6656 _o$6657 _o$6658 _o$6659 _o$6660 _o$6661 _o$6662 _o$6663 _o$6664 _o$6665 _o$6666 _o$6667 _o$6668 _o$6669 _o$6670 _o$6671 _o$6672 _o$6673 _o$6674 _o$6675 _o$6676 _o$6677 _o$6678 _o$6679 _o$6680 _o$6681 _o$6682 _o$6683 _o$6684 _o$6685 _o$6686 _o$6687 _o$6688 _o$6689 _o$6690 _o$6691 _o$6692 _o$6693 _o$6694 _o$6695 _o$6696 _o$6697 _o$6698 _o$6699 _o$6700 _o$6701 _o$6702 _o$6703 _o$6704 _o$6705 _o$6706 _o$6707 _o$6708 _o$6709 _o$6710 _o$6711 _o$6712 _o$6713 _o$6714 _o$6715 _o$6716 _o$6717 _o$6718 _o$6719 _o$6720 _o$6721 _o$6722 _o$6723 _o$6724 _o$6725 _o$6726 _o$6727 _o$6728 _o$6729 _o$6730 _o$6731 _o$6732 _o$6733 _o$6734 _o$6735 _o$6736 _o$6737 _o$6738 _o$6739 _o$6740 _o$6741 _o$6742 _o$6743 _o$6744 _o$6745 _o$6746 _o$6747 _o$6748 _o$6749 _o$6750 _o$6751 _o$6752 _o$6753 _o$6754 _o$6755 _o$6756 _o$6757 _o$6758 _o$6759 _o$6760 _o$6761 _o$6762 _o$6763)) (let* ((_o$6764 (keyword #f "private")) (_o$6765 #t)) (jolt-hash-map _o$6764 _o$6765)))) (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$6643 "+") (_o$6644 "jolt-add") (_o$6645 "-") (_o$6646 "jolt-sub") (_o$6647 "*") (_o$6648 "jolt-mul") (_o$6649 "/") (_o$6650 "jolt-div") (_o$6651 "min") (_o$6652 "jolt-min") (_o$6653 "max") (_o$6654 "jolt-max")) (jolt-hash-map _o$6643 _o$6644 _o$6645 _o$6646 _o$6647 _o$6648 _o$6649 _o$6650 _o$6651 _o$6652 _o$6653 _o$6654))) (let* ((_o$6655 (keyword #f "private")) (_o$6656 #t)) (jolt-hash-map _o$6655 _o$6656)))) + (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$6766 "+") (_o$6767 "jolt-add") (_o$6768 "-") (_o$6769 "jolt-sub") (_o$6770 "*") (_o$6771 "jolt-mul") (_o$6772 "/") (_o$6773 "jolt-div") (_o$6774 "min") (_o$6775 "jolt-min") (_o$6776 "max") (_o$6777 "jolt-max")) (jolt-hash-map _o$6766 _o$6767 _o$6768 _o$6769 _o$6770 _o$6771 _o$6772 _o$6773 _o$6774 _o$6775 _o$6776 _o$6777))) (let* ((_o$6778 (keyword #f "private")) (_o$6779 #t)) (jolt-hash-map _o$6778 _o$6779)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "op-arity" (let* ((_o$6703 "inc") (_o$6704 (lambda (p__42_) (let fnrec6657 ((p__42_ p__42_)) (jolt= p__42_ 1)))) (_o$6705 "dec") (_o$6706 (lambda (p__43_) (let fnrec6658 ((p__43_ p__43_)) (jolt= p__43_ 1)))) (_o$6707 "not") (_o$6708 (lambda (p__44_) (let fnrec6659 ((p__44_ p__44_)) (jolt= p__44_ 1)))) (_o$6709 "count") (_o$6710 (lambda (p__45_) (let fnrec6660 ((p__45_ p__45_)) (jolt= p__45_ 1)))) (_o$6711 "empty?") (_o$6712 (lambda (p__46_) (let fnrec6661 ((p__46_ p__46_)) (jolt= p__46_ 1)))) (_o$6713 "peek") (_o$6714 (lambda (p__47_) (let fnrec6662 ((p__47_ p__47_)) (jolt= p__47_ 1)))) (_o$6715 "pop") (_o$6716 (lambda (p__48_) (let fnrec6663 ((p__48_ p__48_)) (jolt= p__48_ 1)))) (_o$6717 "mod") (_o$6718 (lambda (p__49_) (let fnrec6664 ((p__49_ p__49_)) (jolt= p__49_ 2)))) (_o$6719 "rem") (_o$6720 (lambda (p__50_) (let fnrec6665 ((p__50_ p__50_)) (jolt= p__50_ 2)))) (_o$6721 "quot") (_o$6722 (lambda (p__51_) (let fnrec6666 ((p__51_ p__51_)) (jolt= p__51_ 2)))) (_o$6723 "contains?") (_o$6724 (lambda (p__52_) (let fnrec6667 ((p__52_ p__52_)) (jolt= p__52_ 2)))) (_o$6725 "get") (_o$6726 (lambda (p__53_) (let fnrec6668 ((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$6727 "nth") (_o$6728 (lambda (p__54_) (let fnrec6669 ((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$6729 "assoc") (_o$6730 (lambda (p__55_) (let fnrec6670 ((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$6731 "dissoc") (_o$6732 (lambda (p__56_) (let fnrec6671 ((p__56_ p__56_)) (>= p__56_ 1)))) (_o$6733 "conj") (_o$6734 (lambda (p__57_) (let fnrec6672 ((p__57_ p__57_)) (>= p__57_ 1)))) (_o$6735 "first") (_o$6736 (lambda (p__58_) (let fnrec6673 ((p__58_ p__58_)) (jolt= p__58_ 1)))) (_o$6737 "rest") (_o$6738 (lambda (p__59_) (let fnrec6674 ((p__59_ p__59_)) (jolt= p__59_ 1)))) (_o$6739 "next") (_o$6740 (lambda (p__60_) (let fnrec6675 ((p__60_ p__60_)) (jolt= p__60_ 1)))) (_o$6741 "seq") (_o$6742 (lambda (p__61_) (let fnrec6676 ((p__61_ p__61_)) (jolt= p__61_ 1)))) (_o$6743 "reverse") (_o$6744 (lambda (p__62_) (let fnrec6677 ((p__62_ p__62_)) (jolt= p__62_ 1)))) (_o$6745 "last") (_o$6746 (lambda (p__63_) (let fnrec6678 ((p__63_ p__63_)) (jolt= p__63_ 1)))) (_o$6747 "keys") (_o$6748 (lambda (p__64_) (let fnrec6679 ((p__64_ p__64_)) (jolt= p__64_ 1)))) (_o$6749 "vals") (_o$6750 (lambda (p__65_) (let fnrec6680 ((p__65_ p__65_)) (jolt= p__65_ 1)))) (_o$6751 "even?") (_o$6752 (lambda (p__66_) (let fnrec6681 ((p__66_ p__66_)) (jolt= p__66_ 1)))) (_o$6753 "odd?") (_o$6754 (lambda (p__67_) (let fnrec6682 ((p__67_ p__67_)) (jolt= p__67_ 1)))) (_o$6755 "pos?") (_o$6756 (lambda (p__68_) (let fnrec6683 ((p__68_ p__68_)) (jolt= p__68_ 1)))) (_o$6757 "neg?") (_o$6758 (lambda (p__69_) (let fnrec6684 ((p__69_ p__69_)) (jolt= p__69_ 1)))) (_o$6759 "zero?") (_o$6760 (lambda (p__70_) (let fnrec6685 ((p__70_ p__70_)) (jolt= p__70_ 1)))) (_o$6761 "identity") (_o$6762 (lambda (p__71_) (let fnrec6686 ((p__71_ p__71_)) (jolt= p__71_ 1)))) (_o$6763 "nil?") (_o$6764 (lambda (p__72_) (let fnrec6687 ((p__72_ p__72_)) (jolt= p__72_ 1)))) (_o$6765 "some?") (_o$6766 (lambda (p__73_) (let fnrec6688 ((p__73_ p__73_)) (jolt= p__73_ 1)))) (_o$6767 "protocol-dispatch1") (_o$6768 (lambda (p__74_) (let fnrec6689 ((p__74_ p__74_)) (jolt= p__74_ 3)))) (_o$6769 "protocol-dispatch2") (_o$6770 (lambda (p__75_) (let fnrec6690 ((p__75_ p__75_)) (jolt= p__75_ 4)))) (_o$6771 "protocol-dispatch3") (_o$6772 (lambda (p__76_) (let fnrec6691 ((p__76_ p__76_)) (jolt= p__76_ 5)))) (_o$6773 "cons") (_o$6774 (lambda (p__77_) (let fnrec6692 ((p__77_ p__77_)) (jolt= p__77_ 2)))) (_o$6775 "filter") (_o$6776 (lambda (p__78_) (let fnrec6693 ((p__78_ p__78_)) (jolt= p__78_ 2)))) (_o$6777 "remove") (_o$6778 (lambda (p__79_) (let fnrec6694 ((p__79_ p__79_)) (jolt= p__79_ 2)))) (_o$6779 "into") (_o$6780 (lambda (p__80_) (let fnrec6695 ((p__80_ p__80_)) (jolt= p__80_ 2)))) (_o$6781 "take") (_o$6782 (lambda (p__81_) (let fnrec6696 ((p__81_ p__81_)) (jolt= p__81_ 2)))) (_o$6783 "drop") (_o$6784 (lambda (p__82_) (let fnrec6697 ((p__82_ p__82_)) (jolt= p__82_ 2)))) (_o$6785 "map") (_o$6786 (lambda (p__83_) (let fnrec6698 ((p__83_ p__83_)) (>= p__83_ 2)))) (_o$6787 "apply") (_o$6788 (lambda (p__84_) (let fnrec6699 ((p__84_ p__84_)) (>= p__84_ 2)))) (_o$6789 "reduce") (_o$6790 (lambda (p__85_) (let fnrec6700 ((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$6791 "range") (_o$6792 (lambda (p__86_) (let fnrec6701 ((p__86_ p__86_)) (let* ((and__25__auto (>= p__86_ 0))) (if (jolt-truthy? and__25__auto) (<= p__86_ 3) and__25__auto))))) (_o$6793 "ex-info") (_o$6794 (lambda (p__87_) (let fnrec6702 ((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$6703 _o$6704 _o$6705 _o$6706 _o$6707 _o$6708 _o$6709 _o$6710 _o$6711 _o$6712 _o$6713 _o$6714 _o$6715 _o$6716 _o$6717 _o$6718 _o$6719 _o$6720 _o$6721 _o$6722 _o$6723 _o$6724 _o$6725 _o$6726 _o$6727 _o$6728 _o$6729 _o$6730 _o$6731 _o$6732 _o$6733 _o$6734 _o$6735 _o$6736 _o$6737 _o$6738 _o$6739 _o$6740 _o$6741 _o$6742 _o$6743 _o$6744 _o$6745 _o$6746 _o$6747 _o$6748 _o$6749 _o$6750 _o$6751 _o$6752 _o$6753 _o$6754 _o$6755 _o$6756 _o$6757 _o$6758 _o$6759 _o$6760 _o$6761 _o$6762 _o$6763 _o$6764 _o$6765 _o$6766 _o$6767 _o$6768 _o$6769 _o$6770 _o$6771 _o$6772 _o$6773 _o$6774 _o$6775 _o$6776 _o$6777 _o$6778 _o$6779 _o$6780 _o$6781 _o$6782 _o$6783 _o$6784 _o$6785 _o$6786 _o$6787 _o$6788 _o$6789 _o$6790 _o$6791 _o$6792 _o$6793 _o$6794)) (let* ((_o$6795 (keyword #f "private")) (_o$6796 #t)) (jolt-hash-map _o$6795 _o$6796)))) + (def-var-with-meta! "jolt.backend-scheme" "op-arity" (let* ((_o$6826 "inc") (_o$6827 (lambda (p__42_) (let fnrec6780 ((p__42_ p__42_)) (jolt= p__42_ 1)))) (_o$6828 "dec") (_o$6829 (lambda (p__43_) (let fnrec6781 ((p__43_ p__43_)) (jolt= p__43_ 1)))) (_o$6830 "not") (_o$6831 (lambda (p__44_) (let fnrec6782 ((p__44_ p__44_)) (jolt= p__44_ 1)))) (_o$6832 "count") (_o$6833 (lambda (p__45_) (let fnrec6783 ((p__45_ p__45_)) (jolt= p__45_ 1)))) (_o$6834 "empty?") (_o$6835 (lambda (p__46_) (let fnrec6784 ((p__46_ p__46_)) (jolt= p__46_ 1)))) (_o$6836 "peek") (_o$6837 (lambda (p__47_) (let fnrec6785 ((p__47_ p__47_)) (jolt= p__47_ 1)))) (_o$6838 "pop") (_o$6839 (lambda (p__48_) (let fnrec6786 ((p__48_ p__48_)) (jolt= p__48_ 1)))) (_o$6840 "mod") (_o$6841 (lambda (p__49_) (let fnrec6787 ((p__49_ p__49_)) (jolt= p__49_ 2)))) (_o$6842 "rem") (_o$6843 (lambda (p__50_) (let fnrec6788 ((p__50_ p__50_)) (jolt= p__50_ 2)))) (_o$6844 "quot") (_o$6845 (lambda (p__51_) (let fnrec6789 ((p__51_ p__51_)) (jolt= p__51_ 2)))) (_o$6846 "contains?") (_o$6847 (lambda (p__52_) (let fnrec6790 ((p__52_ p__52_)) (jolt= p__52_ 2)))) (_o$6848 "get") (_o$6849 (lambda (p__53_) (let fnrec6791 ((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$6850 "nth") (_o$6851 (lambda (p__54_) (let fnrec6792 ((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$6852 "assoc") (_o$6853 (lambda (p__55_) (let fnrec6793 ((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$6854 "dissoc") (_o$6855 (lambda (p__56_) (let fnrec6794 ((p__56_ p__56_)) (>= p__56_ 1)))) (_o$6856 "conj") (_o$6857 (lambda (p__57_) (let fnrec6795 ((p__57_ p__57_)) (>= p__57_ 1)))) (_o$6858 "first") (_o$6859 (lambda (p__58_) (let fnrec6796 ((p__58_ p__58_)) (jolt= p__58_ 1)))) (_o$6860 "rest") (_o$6861 (lambda (p__59_) (let fnrec6797 ((p__59_ p__59_)) (jolt= p__59_ 1)))) (_o$6862 "next") (_o$6863 (lambda (p__60_) (let fnrec6798 ((p__60_ p__60_)) (jolt= p__60_ 1)))) (_o$6864 "seq") (_o$6865 (lambda (p__61_) (let fnrec6799 ((p__61_ p__61_)) (jolt= p__61_ 1)))) (_o$6866 "reverse") (_o$6867 (lambda (p__62_) (let fnrec6800 ((p__62_ p__62_)) (jolt= p__62_ 1)))) (_o$6868 "last") (_o$6869 (lambda (p__63_) (let fnrec6801 ((p__63_ p__63_)) (jolt= p__63_ 1)))) (_o$6870 "keys") (_o$6871 (lambda (p__64_) (let fnrec6802 ((p__64_ p__64_)) (jolt= p__64_ 1)))) (_o$6872 "vals") (_o$6873 (lambda (p__65_) (let fnrec6803 ((p__65_ p__65_)) (jolt= p__65_ 1)))) (_o$6874 "even?") (_o$6875 (lambda (p__66_) (let fnrec6804 ((p__66_ p__66_)) (jolt= p__66_ 1)))) (_o$6876 "odd?") (_o$6877 (lambda (p__67_) (let fnrec6805 ((p__67_ p__67_)) (jolt= p__67_ 1)))) (_o$6878 "pos?") (_o$6879 (lambda (p__68_) (let fnrec6806 ((p__68_ p__68_)) (jolt= p__68_ 1)))) (_o$6880 "neg?") (_o$6881 (lambda (p__69_) (let fnrec6807 ((p__69_ p__69_)) (jolt= p__69_ 1)))) (_o$6882 "zero?") (_o$6883 (lambda (p__70_) (let fnrec6808 ((p__70_ p__70_)) (jolt= p__70_ 1)))) (_o$6884 "identity") (_o$6885 (lambda (p__71_) (let fnrec6809 ((p__71_ p__71_)) (jolt= p__71_ 1)))) (_o$6886 "nil?") (_o$6887 (lambda (p__72_) (let fnrec6810 ((p__72_ p__72_)) (jolt= p__72_ 1)))) (_o$6888 "some?") (_o$6889 (lambda (p__73_) (let fnrec6811 ((p__73_ p__73_)) (jolt= p__73_ 1)))) (_o$6890 "protocol-dispatch1") (_o$6891 (lambda (p__74_) (let fnrec6812 ((p__74_ p__74_)) (jolt= p__74_ 3)))) (_o$6892 "protocol-dispatch2") (_o$6893 (lambda (p__75_) (let fnrec6813 ((p__75_ p__75_)) (jolt= p__75_ 4)))) (_o$6894 "protocol-dispatch3") (_o$6895 (lambda (p__76_) (let fnrec6814 ((p__76_ p__76_)) (jolt= p__76_ 5)))) (_o$6896 "cons") (_o$6897 (lambda (p__77_) (let fnrec6815 ((p__77_ p__77_)) (jolt= p__77_ 2)))) (_o$6898 "filter") (_o$6899 (lambda (p__78_) (let fnrec6816 ((p__78_ p__78_)) (jolt= p__78_ 2)))) (_o$6900 "remove") (_o$6901 (lambda (p__79_) (let fnrec6817 ((p__79_ p__79_)) (jolt= p__79_ 2)))) (_o$6902 "into") (_o$6903 (lambda (p__80_) (let fnrec6818 ((p__80_ p__80_)) (jolt= p__80_ 2)))) (_o$6904 "take") (_o$6905 (lambda (p__81_) (let fnrec6819 ((p__81_ p__81_)) (jolt= p__81_ 2)))) (_o$6906 "drop") (_o$6907 (lambda (p__82_) (let fnrec6820 ((p__82_ p__82_)) (jolt= p__82_ 2)))) (_o$6908 "map") (_o$6909 (lambda (p__83_) (let fnrec6821 ((p__83_ p__83_)) (>= p__83_ 2)))) (_o$6910 "apply") (_o$6911 (lambda (p__84_) (let fnrec6822 ((p__84_ p__84_)) (>= p__84_ 2)))) (_o$6912 "reduce") (_o$6913 (lambda (p__85_) (let fnrec6823 ((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$6914 "range") (_o$6915 (lambda (p__86_) (let fnrec6824 ((p__86_ p__86_)) (let* ((and__25__auto (>= p__86_ 0))) (if (jolt-truthy? and__25__auto) (<= p__86_ 3) and__25__auto))))) (_o$6916 "ex-info") (_o$6917 (lambda (p__87_) (let fnrec6825 ((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$6826 _o$6827 _o$6828 _o$6829 _o$6830 _o$6831 _o$6832 _o$6833 _o$6834 _o$6835 _o$6836 _o$6837 _o$6838 _o$6839 _o$6840 _o$6841 _o$6842 _o$6843 _o$6844 _o$6845 _o$6846 _o$6847 _o$6848 _o$6849 _o$6850 _o$6851 _o$6852 _o$6853 _o$6854 _o$6855 _o$6856 _o$6857 _o$6858 _o$6859 _o$6860 _o$6861 _o$6862 _o$6863 _o$6864 _o$6865 _o$6866 _o$6867 _o$6868 _o$6869 _o$6870 _o$6871 _o$6872 _o$6873 _o$6874 _o$6875 _o$6876 _o$6877 _o$6878 _o$6879 _o$6880 _o$6881 _o$6882 _o$6883 _o$6884 _o$6885 _o$6886 _o$6887 _o$6888 _o$6889 _o$6890 _o$6891 _o$6892 _o$6893 _o$6894 _o$6895 _o$6896 _o$6897 _o$6898 _o$6899 _o$6900 _o$6901 _o$6902 _o$6903 _o$6904 _o$6905 _o$6906 _o$6907 _o$6908 _o$6909 _o$6910 _o$6911 _o$6912 _o$6913 _o$6914 _o$6915 _o$6916 _o$6917)) (let* ((_o$6918 (keyword #f "private")) (_o$6919 #t)) (jolt-hash-map _o$6918 _o$6919)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "cmp1-ops" (let* ((_o$6797 "<") (_o$6798 ">") (_o$6799 "<=") (_o$6800 ">=")) (jolt-hash-set _o$6797 _o$6798 _o$6799 _o$6800)) (let* ((_o$6801 (keyword #f "private")) (_o$6802 #t)) (jolt-hash-map _o$6801 _o$6802)))) + (def-var-with-meta! "jolt.backend-scheme" "cmp1-ops" (let* ((_o$6920 "<") (_o$6921 ">") (_o$6922 "<=") (_o$6923 ">=")) (jolt-hash-set _o$6920 _o$6921 _o$6922 _o$6923)) (let* ((_o$6924 (keyword #f "private")) (_o$6925 #t)) (jolt-hash-map _o$6924 _o$6925)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "supported-host-methods" (let* ((_o$6803 "isDirectory") (_o$6804 "listFiles")) (jolt-hash-set _o$6803 _o$6804)) (let* ((_o$6805 (keyword #f "private")) (_o$6806 #t)) (jolt-hash-map _o$6805 _o$6806)))) + (def-var-with-meta! "jolt.backend-scheme" "supported-host-methods" (let* ((_o$6926 "isDirectory") (_o$6927 "listFiles")) (jolt-hash-set _o$6926 _o$6927)) (let* ((_o$6928 (keyword #f "private")) (_o$6929 #t)) (jolt-hash-map _o$6928 _o$6929)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "bool-returning-ops" (let* ((_o$6807 "<") (_o$6808 "<=") (_o$6809 ">") (_o$6810 ">=") (_o$6811 "jolt=") (_o$6812 "jolt-not") (_o$6813 "jolt-even?") (_o$6814 "jolt-odd?") (_o$6815 "jolt-pos?") (_o$6816 "jolt-neg?") (_o$6817 "jolt-zero?") (_o$6818 "jolt-empty?") (_o$6819 "jolt-contains?") (_o$6820 "jolt-nil?") (_o$6821 "jolt-some?")) (jolt-hash-set _o$6807 _o$6808 _o$6809 _o$6810 _o$6811 _o$6812 _o$6813 _o$6814 _o$6815 _o$6816 _o$6817 _o$6818 _o$6819 _o$6820 _o$6821)) (let* ((_o$6822 (keyword #f "private")) (_o$6823 #t)) (jolt-hash-map _o$6822 _o$6823)))) + (def-var-with-meta! "jolt.backend-scheme" "bool-returning-ops" (let* ((_o$6930 "<") (_o$6931 "<=") (_o$6932 ">") (_o$6933 ">=") (_o$6934 "jolt=") (_o$6935 "jolt-not") (_o$6936 "jolt-even?") (_o$6937 "jolt-odd?") (_o$6938 "jolt-pos?") (_o$6939 "jolt-neg?") (_o$6940 "jolt-zero?") (_o$6941 "jolt-empty?") (_o$6942 "jolt-contains?") (_o$6943 "jolt-nil?") (_o$6944 "jolt-some?")) (jolt-hash-set _o$6930 _o$6931 _o$6932 _o$6933 _o$6934 _o$6935 _o$6936 _o$6937 _o$6938 _o$6939 _o$6940 _o$6941 _o$6942 _o$6943 _o$6944)) (let* ((_o$6945 (keyword #f "private")) (_o$6946 #t)) (jolt-hash-map _o$6945 _o$6946)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "dbl-ops" (let* ((_o$6824 "+") (_o$6825 "fl+") (_o$6826 "-") (_o$6827 "fl-") (_o$6828 "*") (_o$6829 "fl*") (_o$6830 "/") (_o$6831 "fl/") (_o$6832 "min") (_o$6833 "flmin") (_o$6834 "max") (_o$6835 "flmax") (_o$6836 "<") (_o$6837 "fl") (_o$6839 "fl>?") (_o$6840 "<=") (_o$6841 "fl<=?") (_o$6842 ">=") (_o$6843 "fl>=?") (_o$6844 "=") (_o$6845 "fl=?") (_o$6846 "==") (_o$6847 "fl=?")) (jolt-hash-map _o$6824 _o$6825 _o$6826 _o$6827 _o$6828 _o$6829 _o$6830 _o$6831 _o$6832 _o$6833 _o$6834 _o$6835 _o$6836 _o$6837 _o$6838 _o$6839 _o$6840 _o$6841 _o$6842 _o$6843 _o$6844 _o$6845 _o$6846 _o$6847)) (let* ((_o$6848 (keyword #f "private")) (_o$6849 #t)) (jolt-hash-map _o$6848 _o$6849)))) + (def-var-with-meta! "jolt.backend-scheme" "dbl-ops" (let* ((_o$6947 "+") (_o$6948 "fl+") (_o$6949 "-") (_o$6950 "fl-") (_o$6951 "*") (_o$6952 "fl*") (_o$6953 "/") (_o$6954 "fl/") (_o$6955 "min") (_o$6956 "flmin") (_o$6957 "max") (_o$6958 "flmax") (_o$6959 "<") (_o$6960 "fl") (_o$6962 "fl>?") (_o$6963 "<=") (_o$6964 "fl<=?") (_o$6965 ">=") (_o$6966 "fl>=?") (_o$6967 "=") (_o$6968 "fl=?") (_o$6969 "==") (_o$6970 "fl=?")) (jolt-hash-map _o$6947 _o$6948 _o$6949 _o$6950 _o$6951 _o$6952 _o$6953 _o$6954 _o$6955 _o$6956 _o$6957 _o$6958 _o$6959 _o$6960 _o$6961 _o$6962 _o$6963 _o$6964 _o$6965 _o$6966 _o$6967 _o$6968 _o$6969 _o$6970)) (let* ((_o$6971 (keyword #f "private")) (_o$6972 #t)) (jolt-hash-map _o$6971 _o$6972)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "lng-ops" (let* ((_o$6850 "+") (_o$6851 "fx+") (_o$6852 "-") (_o$6853 "fx-") (_o$6854 "*") (_o$6855 "fx*") (_o$6856 "min") (_o$6857 "fxmin") (_o$6858 "max") (_o$6859 "fxmax") (_o$6860 "unchecked-add") (_o$6861 "fx+") (_o$6862 "unchecked-subtract") (_o$6863 "fx-") (_o$6864 "unchecked-multiply") (_o$6865 "fx*") (_o$6866 "quot") (_o$6867 "fxquotient") (_o$6868 "rem") (_o$6869 "fxremainder") (_o$6870 "mod") (_o$6871 "fxmodulo") (_o$6872 "<") (_o$6873 "fx") (_o$6875 "fx>?") (_o$6876 "<=") (_o$6877 "fx<=?") (_o$6878 ">=") (_o$6879 "fx>=?") (_o$6880 "=") (_o$6881 "fx=?") (_o$6882 "==") (_o$6883 "fx=?")) (jolt-hash-map _o$6850 _o$6851 _o$6852 _o$6853 _o$6854 _o$6855 _o$6856 _o$6857 _o$6858 _o$6859 _o$6860 _o$6861 _o$6862 _o$6863 _o$6864 _o$6865 _o$6866 _o$6867 _o$6868 _o$6869 _o$6870 _o$6871 _o$6872 _o$6873 _o$6874 _o$6875 _o$6876 _o$6877 _o$6878 _o$6879 _o$6880 _o$6881 _o$6882 _o$6883)) (let* ((_o$6884 (keyword #f "private")) (_o$6885 #t)) (jolt-hash-map _o$6884 _o$6885)))) + (def-var-with-meta! "jolt.backend-scheme" "lng-ops" (let* ((_o$6973 "+") (_o$6974 "fx+") (_o$6975 "-") (_o$6976 "fx-") (_o$6977 "*") (_o$6978 "fx*") (_o$6979 "min") (_o$6980 "fxmin") (_o$6981 "max") (_o$6982 "fxmax") (_o$6983 "unchecked-add") (_o$6984 "fx+") (_o$6985 "unchecked-subtract") (_o$6986 "fx-") (_o$6987 "unchecked-multiply") (_o$6988 "fx*") (_o$6989 "quot") (_o$6990 "fxquotient") (_o$6991 "rem") (_o$6992 "fxremainder") (_o$6993 "mod") (_o$6994 "fxmodulo") (_o$6995 "<") (_o$6996 "fx") (_o$6998 "fx>?") (_o$6999 "<=") (_o$7000 "fx<=?") (_o$7001 ">=") (_o$7002 "fx>=?") (_o$7003 "=") (_o$7004 "fx=?") (_o$7005 "==") (_o$7006 "fx=?")) (jolt-hash-map _o$6973 _o$6974 _o$6975 _o$6976 _o$6977 _o$6978 _o$6979 _o$6980 _o$6981 _o$6982 _o$6983 _o$6984 _o$6985 _o$6986 _o$6987 _o$6988 _o$6989 _o$6990 _o$6991 _o$6992 _o$6993 _o$6994 _o$6995 _o$6996 _o$6997 _o$6998 _o$6999 _o$7000 _o$7001 _o$7002 _o$7003 _o$7004 _o$7005 _o$7006)) (let* ((_o$7007 (keyword #f "private")) (_o$7008 #t)) (jolt-hash-map _o$7007 _o$7008)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "bd-ops" (let* ((_o$6886 "+") (_o$6887 "jbd-add") (_o$6888 "-") (_o$6889 "jbd-sub") (_o$6890 "*") (_o$6891 "jbd-mul") (_o$6892 "/") (_o$6893 "jbd-div") (_o$6894 "min") (_o$6895 "jbd-min") (_o$6896 "max") (_o$6897 "jbd-max") (_o$6898 "quot") (_o$6899 "jbd-quot") (_o$6900 "rem") (_o$6901 "jbd-rem") (_o$6902 "<") (_o$6903 "jbd-lt?") (_o$6904 ">") (_o$6905 "jbd-gt?") (_o$6906 "<=") (_o$6907 "jbd-le?") (_o$6908 ">=") (_o$6909 "jbd-ge?") (_o$6910 "zero?") (_o$6911 "jbd-zero?") (_o$6912 "pos?") (_o$6913 "jbd-pos?") (_o$6914 "neg?") (_o$6915 "jbd-neg?")) (jolt-hash-map _o$6886 _o$6887 _o$6888 _o$6889 _o$6890 _o$6891 _o$6892 _o$6893 _o$6894 _o$6895 _o$6896 _o$6897 _o$6898 _o$6899 _o$6900 _o$6901 _o$6902 _o$6903 _o$6904 _o$6905 _o$6906 _o$6907 _o$6908 _o$6909 _o$6910 _o$6911 _o$6912 _o$6913 _o$6914 _o$6915)) (let* ((_o$6916 (keyword #f "private")) (_o$6917 #t)) (jolt-hash-map _o$6916 _o$6917)))) + (def-var-with-meta! "jolt.backend-scheme" "bd-ops" (let* ((_o$7009 "+") (_o$7010 "jbd-add") (_o$7011 "-") (_o$7012 "jbd-sub") (_o$7013 "*") (_o$7014 "jbd-mul") (_o$7015 "/") (_o$7016 "jbd-div") (_o$7017 "min") (_o$7018 "jbd-min") (_o$7019 "max") (_o$7020 "jbd-max") (_o$7021 "quot") (_o$7022 "jbd-quot") (_o$7023 "rem") (_o$7024 "jbd-rem") (_o$7025 "<") (_o$7026 "jbd-lt?") (_o$7027 ">") (_o$7028 "jbd-gt?") (_o$7029 "<=") (_o$7030 "jbd-le?") (_o$7031 ">=") (_o$7032 "jbd-ge?") (_o$7033 "zero?") (_o$7034 "jbd-zero?") (_o$7035 "pos?") (_o$7036 "jbd-pos?") (_o$7037 "neg?") (_o$7038 "jbd-neg?")) (jolt-hash-map _o$7009 _o$7010 _o$7011 _o$7012 _o$7013 _o$7014 _o$7015 _o$7016 _o$7017 _o$7018 _o$7019 _o$7020 _o$7021 _o$7022 _o$7023 _o$7024 _o$7025 _o$7026 _o$7027 _o$7028 _o$7029 _o$7030 _o$7031 _o$7032 _o$7033 _o$7034 _o$7035 _o$7036 _o$7037 _o$7038)) (let* ((_o$7039 (keyword #f "private")) (_o$7040 #t)) (jolt-hash-map _o$7039 _o$7040)))) (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 fnrec6918 ((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 fnrec7041 ((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 fnrec6919 ((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 fnrec7042 ((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 fnrec6920 () (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 fnrec7043 () (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! "jolt.backend-scheme" "dl-munge" (letrec ((dl-munge (lambda (s) (let fnrec6921 ((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))) + (def-var! "jolt.backend-scheme" "dl-munge" (letrec ((dl-munge (lambda (s) (let fnrec7044 ((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))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "dl-name" (letrec ((dl-name (lambda (ns nm) (let fnrec6922 ((ns ns) (nm nm)) (let* ((_a$6923 (var-deref "clojure.core" "str")) (_a$6924 "jv$") (_a$6925 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") ns)) (_a$6926 "$") (_a$6927 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") nm))) (jolt-invoke _a$6923 _a$6924 _a$6925 _a$6926 _a$6927)))))) dl-name))) + (def-var! "jolt.backend-scheme" "dl-name" (letrec ((dl-name (lambda (ns nm) (let fnrec7045 ((ns ns) (nm nm)) (let* ((_a$7046 (var-deref "clojure.core" "str")) (_a$7047 "jv$") (_a$7048 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") ns)) (_a$7049 "$") (_a$7050 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") nm))) (jolt-invoke _a$7046 _a$7047 _a$7048 _a$7049 _a$7050)))))) dl-name))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "dl-fqn" (letrec ((dl-fqn (lambda (ns nm) (let fnrec6928 ((ns ns) (nm nm)) (jolt-invoke (var-deref "clojure.core" "str") ns "/" nm))))) dl-fqn))) + (def-var! "jolt.backend-scheme" "dl-fqn" (letrec ((dl-fqn (lambda (ns nm) (let fnrec7051 ((ns ns) (nm nm)) (jolt-invoke (var-deref "clojure.core" "str") ns "/" nm))))) dl-fqn))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "direct-linkable?" (letrec ((direct-linkable? (lambda (ns nm) (let fnrec6929 ((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$6930 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-defined"))) (_a$6931 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$6930 _a$6931)) and__25__auto)))))) direct-linkable?))) + (def-var! "jolt.backend-scheme" "direct-linkable?" (letrec ((direct-linkable? (lambda (ns nm) (let fnrec7052 ((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$7053 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-defined"))) (_a$7054 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$7053 _a$7054)) and__25__auto)))))) direct-linkable?))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "direct-link-fn?" (letrec ((direct-link-fn? (lambda (ns nm) (let fnrec6932 ((ns ns) (nm nm)) (let* ((_a$6933 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-fns"))) (_a$6934 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$6933 _a$6934)))))) direct-link-fn?))) + (def-var! "jolt.backend-scheme" "direct-link-fn?" (letrec ((direct-link-fn? (lambda (ns nm) (let fnrec7055 ((ns ns) (nm nm)) (let* ((_a$7056 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-fns"))) (_a$7057 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$7056 _a$7057)))))) direct-link-fn?))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "*recur-target*" jolt-nil (let* ((_o$6935 (keyword #f "dynamic")) (_o$6936 #t)) (jolt-hash-map _o$6935 _o$6936)))) + (def-var-with-meta! "jolt.backend-scheme" "*recur-target*" jolt-nil (let* ((_o$7058 (keyword #f "dynamic")) (_o$7059 #t)) (jolt-hash-map _o$7058 _o$7059)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "*known-procs*" (jolt-hash-set) (let* ((_o$6937 (keyword #f "dynamic")) (_o$6938 #t)) (jolt-hash-map _o$6937 _o$6938)))) + (def-var-with-meta! "jolt.backend-scheme" "*known-procs*" (jolt-hash-set) (let* ((_o$7060 (keyword #f "dynamic")) (_o$7061 #t)) (jolt-hash-map _o$7060 _o$7061)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "gensym-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$6939 (keyword #f "private")) (_o$6940 #t)) (jolt-hash-map _o$6939 _o$6940)))) + (def-var-with-meta! "jolt.backend-scheme" "gensym-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$7062 (keyword #f "private")) (_o$7063 #t)) (jolt-hash-map _o$7062 _o$7063)))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "fresh-label" (letrec ((fresh-label (lambda (prefix) (let fnrec6941 ((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))) + (def-var! "jolt.backend-scheme" "fresh-label" (letrec ((fresh-label (lambda (prefix) (let fnrec7064 ((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))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "scheme-reserved" (let* ((_o$6942 "if") (_o$6943 "begin") (_o$6944 "lambda") (_o$6945 "let") (_o$6946 "let*") (_o$6947 "letrec") (_o$6948 "letrec*") (_o$6949 "quote") (_o$6950 "quasiquote") (_o$6951 "unquote") (_o$6952 "set!") (_o$6953 "define") (_o$6954 "define-syntax") (_o$6955 "cond") (_o$6956 "case") (_o$6957 "when") (_o$6958 "unless") (_o$6959 "and") (_o$6960 "or") (_o$6961 "do") (_o$6962 "else") (_o$6963 "guard") (_o$6964 "parameterize") (_o$6965 "delay") (_o$6966 "values")) (jolt-hash-set _o$6942 _o$6943 _o$6944 _o$6945 _o$6946 _o$6947 _o$6948 _o$6949 _o$6950 _o$6951 _o$6952 _o$6953 _o$6954 _o$6955 _o$6956 _o$6957 _o$6958 _o$6959 _o$6960 _o$6961 _o$6962 _o$6963 _o$6964 _o$6965 _o$6966)) (let* ((_o$6967 (keyword #f "private")) (_o$6968 #t)) (jolt-hash-map _o$6967 _o$6968)))) + (def-var-with-meta! "jolt.backend-scheme" "scheme-reserved" (let* ((_o$7065 "if") (_o$7066 "begin") (_o$7067 "lambda") (_o$7068 "let") (_o$7069 "let*") (_o$7070 "letrec") (_o$7071 "letrec*") (_o$7072 "quote") (_o$7073 "quasiquote") (_o$7074 "unquote") (_o$7075 "set!") (_o$7076 "define") (_o$7077 "define-syntax") (_o$7078 "cond") (_o$7079 "case") (_o$7080 "when") (_o$7081 "unless") (_o$7082 "and") (_o$7083 "or") (_o$7084 "do") (_o$7085 "else") (_o$7086 "guard") (_o$7087 "parameterize") (_o$7088 "delay") (_o$7089 "values")) (jolt-hash-set _o$7065 _o$7066 _o$7067 _o$7068 _o$7069 _o$7070 _o$7071 _o$7072 _o$7073 _o$7074 _o$7075 _o$7076 _o$7077 _o$7078 _o$7079 _o$7080 _o$7081 _o$7082 _o$7083 _o$7084 _o$7085 _o$7086 _o$7087 _o$7088 _o$7089)) (let* ((_o$7090 (keyword #f "private")) (_o$7091 #t)) (jolt-hash-map _o$7090 _o$7091)))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "munge-name" (letrec ((munge-name (lambda (s) (let fnrec6969 ((s s)) (let* ((s (jolt-invoke (var-deref "clojure.string" "replace") (jolt-invoke (var-deref "clojure.string" "replace") s "#" "_") "'" "_PRIME_"))) (if (jolt-contains? (var-deref "jolt.backend-scheme" "scheme-reserved") s) (jolt-invoke (var-deref "clojure.core" "str") "_" s) s)))))) munge-name))) + (def-var! "jolt.backend-scheme" "munge-name" (letrec ((munge-name (lambda (s) (let fnrec7092 ((s s)) (let* ((s (jolt-invoke (var-deref "clojure.string" "replace") (jolt-invoke (var-deref "clojure.string" "replace") s "#" "_") "'" "_PRIME_"))) (if (jolt-contains? (var-deref "jolt.backend-scheme" "scheme-reserved") s) (jolt-invoke (var-deref "clojure.core" "str") "_" s) s)))))) munge-name))) (guard (e (#t #f)) (declare-var! "jolt.backend-scheme" "emit")) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "char-escape" (letrec ((char-escape (lambda (cp) (let fnrec6970 ((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))) + (def-var! "jolt.backend-scheme" "char-escape" (letrec ((char-escape (lambda (cp) (let fnrec7093 ((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))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "chez-str-lit" (letrec ((chez-str-lit (lambda (s) (let fnrec6971 ((s s)) (jolt-invoke (var-deref "clojure.core" "str") "\"" (jolt-apply (var-deref "clojure.core" "str") (jolt-map (lambda (c) (let fnrec6972 ((c c)) (jolt-invoke (var-deref "jolt.backend-scheme" "char-escape") (jolt-invoke (var-deref "clojure.core" "int") c)))) s)) "\""))))) chez-str-lit))) + (def-var! "jolt.backend-scheme" "chez-str-lit" (letrec ((chez-str-lit (lambda (s) (let fnrec7094 ((s s)) (jolt-invoke (var-deref "clojure.core" "str") "\"" (jolt-apply (var-deref "clojure.core" "str") (jolt-map (lambda (c) (let fnrec7095 ((c c)) (jolt-invoke (var-deref "jolt.backend-scheme" "char-escape") (jolt-invoke (var-deref "clojure.core" "int") c)))) s)) "\""))))) chez-str-lit))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit-const" (letrec ((emit-const (lambda (v) (let fnrec6973 ((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$6974 (var-deref "clojure.core" "str")) (_a$6975 "(keyword ") (_a$6976 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") kns)) (_a$6977 " ") (_a$6978 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "clojure.core" "name") v))) (_a$6979 ")")) (jolt-invoke _a$6974 _a$6975 _a$6976 _a$6977 _a$6978 _a$6979))) (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$6980 (jolt-invoke (var-deref "clojure.core" "str") "emit-const: unsupported literal " (jolt-invoke (var-deref "clojure.core" "pr-str") v))) (_a$6981 (jolt-hash-map))) (jolt-ex-info _a$6980 _a$6981))) jolt-nil))))))))))) emit-const))) + (def-var! "jolt.backend-scheme" "emit-const" (letrec ((emit-const (lambda (v) (let fnrec7096 ((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$7097 (var-deref "clojure.core" "str")) (_a$7098 "(keyword ") (_a$7099 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") kns)) (_a$7100 " ") (_a$7101 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "clojure.core" "name") v))) (_a$7102 ")")) (jolt-invoke _a$7097 _a$7098 _a$7099 _a$7100 _a$7101 _a$7102))) (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$7103 (jolt-invoke (var-deref "clojure.core" "str") "emit-const: unsupported literal " (jolt-invoke (var-deref "clojure.core" "pr-str") v))) (_a$7104 (jolt-hash-map))) (jolt-ex-info _a$7103 _a$7104))) jolt-nil))))))))))) emit-const))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit-ordered" (letrec ((emit-ordered (lambda (ctor arg-strs) (let fnrec6982 ((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 fnrec6983 ((_ _)) (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 fnrec6984 ((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))) + (def-var! "jolt.backend-scheme" "emit-ordered" (letrec ((emit-ordered (lambda (ctor arg-strs) (let fnrec7105 ((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 fnrec7106 ((_ _)) (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 fnrec7107 ((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))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "side-effect-free?" (letrec ((side-effect-free? (lambda (n) (let fnrec6985 ((n n)) (let* ((_a$6991 (let* ((_o$6986 (keyword #f "const")) (_o$6987 (keyword #f "local")) (_o$6988 (keyword #f "var")) (_o$6989 (keyword #f "the-var")) (_o$6990 (keyword #f "quote"))) (jolt-hash-set _o$6986 _o$6987 _o$6988 _o$6989 _o$6990))) (_a$6992 (jolt-get n (keyword #f "op")))) (jolt-contains? _a$6991 _a$6992)))))) side-effect-free?))) + (def-var! "jolt.backend-scheme" "side-effect-free?" (letrec ((side-effect-free? (lambda (n) (let fnrec7108 ((n n)) (let* ((_a$7114 (let* ((_o$7109 (keyword #f "const")) (_o$7110 (keyword #f "local")) (_o$7111 (keyword #f "var")) (_o$7112 (keyword #f "the-var")) (_o$7113 (keyword #f "quote"))) (jolt-hash-set _o$7109 _o$7110 _o$7111 _o$7112 _o$7113))) (_a$7115 (jolt-get n (keyword #f "op")))) (jolt-contains? _a$7114 _a$7115)))))) side-effect-free?))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "needs-order?" (letrec ((needs-order? (lambda (nodes) (let fnrec6993 ((nodes nodes)) (> (jolt-count (jolt-remove (var-deref "jolt.backend-scheme" "side-effect-free?") nodes)) 1))))) needs-order?))) + (def-var! "jolt.backend-scheme" "needs-order?" (letrec ((needs-order? (lambda (nodes) (let fnrec7116 ((nodes nodes)) (> (jolt-count (jolt-remove (var-deref "jolt.backend-scheme" "side-effect-free?") nodes)) 1))))) needs-order?))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "ordered-call" (letrec ((ordered-call (lambda (nodes strs build) (let fnrec6994 ((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 fnrec6995 ((_ _)) (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 fnrec6996 ((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))) + (def-var! "jolt.backend-scheme" "ordered-call" (letrec ((ordered-call (lambda (nodes strs build) (let fnrec7117 ((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 fnrec7118 ((_ _)) (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 fnrec7119 ((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))) (guard (e (#t #f)) (declare-var! "jolt.backend-scheme" "emit-quoted")) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit-quoted-map" (letrec ((emit-quoted-map (lambda (pairs) (let fnrec6997 ((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 fnrec6998 ((p p)) (let* ((_o$6999 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 0))) (_o$7000 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 1)))) (jolt-vector _o$6999 _o$7000)))) pairs)) ")"))))) emit-quoted-map))) + (def-var! "jolt.backend-scheme" "emit-quoted-map" (letrec ((emit-quoted-map (lambda (pairs) (let fnrec7120 ((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 fnrec7121 ((p p)) (let* ((_o$7122 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 0))) (_o$7123 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 1)))) (jolt-vector _o$7122 _o$7123)))) pairs)) ")"))))) emit-quoted-map))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit-quoted-map-value" (letrec ((emit-quoted-map-value (lambda (m) (let fnrec7001 ((m m)) (let* ((pairs (jolt-invoke (var-deref "clojure.core" "sort") (let* ((_a$7007 (lambda (k) (let fnrec7002 ((k k)) (let* ((_a$7003 (var-deref "clojure.core" "str")) (_a$7004 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") k)) (_a$7005 " ") (_a$7006 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get m k)))) (jolt-invoke _a$7003 _a$7004 _a$7005 _a$7006))))) (_a$7008 (jolt-keys m))) (jolt-map _a$7007 _a$7008))))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-map " (jolt-invoke (var-deref "clojure.string" "join") " " pairs) ")")))))) emit-quoted-map-value))) + (def-var! "jolt.backend-scheme" "emit-quoted-map-value" (letrec ((emit-quoted-map-value (lambda (m) (let fnrec7124 ((m m)) (let* ((pairs (jolt-invoke (var-deref "clojure.core" "sort") (let* ((_a$7130 (lambda (k) (let fnrec7125 ((k k)) (let* ((_a$7126 (var-deref "clojure.core" "str")) (_a$7127 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") k)) (_a$7128 " ") (_a$7129 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get m k)))) (jolt-invoke _a$7126 _a$7127 _a$7128 _a$7129))))) (_a$7131 (jolt-keys m))) (jolt-map _a$7130 _a$7131))))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-map " (jolt-invoke (var-deref "clojure.string" "join") " " pairs) ")")))))) emit-quoted-map-value))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit-quoted" (letrec ((emit-quoted (lambda (form) (let fnrec7009 ((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$7010 (var-deref "clojure.core" "str")) (_a$7011 "(jolt-symbol/meta ") (_a$7012 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$7013 " ") (_a$7014 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7015 " ") (_a$7016 (emit-quoted m)) (_a$7017 ")")) (jolt-invoke _a$7010 _a$7011 _a$7012 _a$7013 _a$7014 _a$7015 _a$7016 _a$7017)) (let* ((_a$7018 (var-deref "clojure.core" "str")) (_a$7019 "(jolt-symbol ") (_a$7020 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$7021 " ") (_a$7022 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7023 ")")) (jolt-invoke _a$7018 _a$7019 _a$7020 _a$7021 _a$7022 _a$7023)))) (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 "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$7024 (jolt-invoke (var-deref "clojure.core" "str") "emit-quoted: unsupported quoted form " (jolt-invoke (var-deref "clojure.core" "pr-str") form))) (_a$7025 (jolt-hash-map))) (jolt-ex-info _a$7024 _a$7025))) jolt-nil))))))))))))))))) emit-quoted))) + (def-var! "jolt.backend-scheme" "emit-quoted" (letrec ((emit-quoted (lambda (form) (let fnrec7132 ((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$7133 (var-deref "clojure.core" "str")) (_a$7134 "(jolt-symbol/meta ") (_a$7135 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$7136 " ") (_a$7137 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7138 " ") (_a$7139 (emit-quoted m)) (_a$7140 ")")) (jolt-invoke _a$7133 _a$7134 _a$7135 _a$7136 _a$7137 _a$7138 _a$7139 _a$7140)) (let* ((_a$7141 (var-deref "clojure.core" "str")) (_a$7142 "(jolt-symbol ") (_a$7143 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$7144 " ") (_a$7145 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7146 ")")) (jolt-invoke _a$7141 _a$7142 _a$7143 _a$7144 _a$7145 _a$7146)))) (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 "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$7147 (jolt-invoke (var-deref "clojure.core" "str") "emit-quoted: unsupported quoted form " (jolt-invoke (var-deref "clojure.core" "pr-str") form))) (_a$7148 (jolt-hash-map))) (jolt-ex-info _a$7147 _a$7148))) jolt-nil))))))))))))))))) emit-quoted))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "jmeta-nonempty?" (letrec ((jmeta-nonempty? (lambda (m) (let fnrec7026 ((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?))) + (def-var! "jolt.backend-scheme" "jmeta-nonempty?" (letrec ((jmeta-nonempty? (lambda (m) (let fnrec7149 ((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?))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit-def-meta" (letrec ((emit-def-meta (lambda (node) (let fnrec7027 ((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))) + (def-var! "jolt.backend-scheme" "emit-def-meta" (letrec ((emit-def-meta (lambda (node) (let fnrec7150 ((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))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit-binding" (letrec ((emit-binding (lambda (b) (let fnrec7028 ((b b)) (let* ((_a$7029 (var-deref "clojure.core" "str")) (_a$7030 "(") (_a$7031 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-nth b 0))) (_a$7032 " ") (_a$7033 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth b 1))) (_a$7034 ")")) (jolt-invoke _a$7029 _a$7030 _a$7031 _a$7032 _a$7033 _a$7034)))))) emit-binding))) + (def-var! "jolt.backend-scheme" "emit-binding" (letrec ((emit-binding (lambda (b) (let fnrec7151 ((b b)) (let* ((_a$7152 (var-deref "clojure.core" "str")) (_a$7153 "(") (_a$7154 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-nth b 0))) (_a$7155 " ") (_a$7156 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth b 1))) (_a$7157 ")")) (jolt-invoke _a$7152 _a$7153 _a$7154 _a$7155 _a$7156 _a$7157)))))) emit-binding))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit-let" (letrec ((emit-let (lambda (node) (let fnrec7035 ((node node)) (let* ((kw (if (jolt-truthy? (jolt-get node (keyword #f "letrec"))) "letrec*" "let*"))) (let* ((_a$7036 (var-deref "clojure.core" "str")) (_a$7037 "(") (_a$7038 kw) (_a$7039 " (") (_a$7040 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "emit-binding") (jolt-get node (keyword #f "bindings"))))) (_a$7041 ") ") (_a$7042 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$7043 ")")) (jolt-invoke _a$7036 _a$7037 _a$7038 _a$7039 _a$7040 _a$7041 _a$7042 _a$7043))))))) emit-let))) + (def-var! "jolt.backend-scheme" "emit-let" (letrec ((emit-let (lambda (node) (let fnrec7158 ((node node)) (let* ((kw (if (jolt-truthy? (jolt-get node (keyword #f "letrec"))) "letrec*" "let*"))) (let* ((_a$7159 (var-deref "clojure.core" "str")) (_a$7160 "(") (_a$7161 kw) (_a$7162 " (") (_a$7163 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "emit-binding") (jolt-get node (keyword #f "bindings"))))) (_a$7164 ") ") (_a$7165 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$7166 ")")) (jolt-invoke _a$7159 _a$7160 _a$7161 _a$7162 _a$7163 _a$7164 _a$7165 _a$7166))))))) emit-let))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit-loop" (letrec ((emit-loop (lambda (node) (let fnrec7044 ((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 fnrec7045 ((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 fnrec7046 ((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 fnrec7047 ((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 fnrec7048 ((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))) + (def-var! "jolt.backend-scheme" "emit-loop" (letrec ((emit-loop (lambda (node) (let fnrec7167 ((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 fnrec7168 ((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 fnrec7169 ((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 fnrec7170 ((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 fnrec7171 ((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))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "ffi-types" (let* ((_o$7049 "int") (_o$7050 "int") (_o$7051 "uint") (_o$7052 "unsigned-int") (_o$7053 "long") (_o$7054 "long") (_o$7055 "ulong") (_o$7056 "unsigned-long") (_o$7057 "int64") (_o$7058 "integer-64") (_o$7059 "uint64") (_o$7060 "unsigned-64") (_o$7061 "size_t") (_o$7062 "size_t") (_o$7063 "ssize_t") (_o$7064 "ssize_t") (_o$7065 "iptr") (_o$7066 "iptr") (_o$7067 "uptr") (_o$7068 "uptr") (_o$7069 "double") (_o$7070 "double") (_o$7071 "float") (_o$7072 "float") (_o$7073 "pointer") (_o$7074 "void*") (_o$7075 "void*") (_o$7076 "void*") (_o$7077 "string") (_o$7078 "string") (_o$7079 "void") (_o$7080 "void") (_o$7081 "uint8") (_o$7082 "unsigned-8") (_o$7083 "u8") (_o$7084 "unsigned-8") (_o$7085 "byte") (_o$7086 "unsigned-8") (_o$7087 "char") (_o$7088 "char")) (jolt-hash-map _o$7049 _o$7050 _o$7051 _o$7052 _o$7053 _o$7054 _o$7055 _o$7056 _o$7057 _o$7058 _o$7059 _o$7060 _o$7061 _o$7062 _o$7063 _o$7064 _o$7065 _o$7066 _o$7067 _o$7068 _o$7069 _o$7070 _o$7071 _o$7072 _o$7073 _o$7074 _o$7075 _o$7076 _o$7077 _o$7078 _o$7079 _o$7080 _o$7081 _o$7082 _o$7083 _o$7084 _o$7085 _o$7086 _o$7087 _o$7088)) (let* ((_o$7089 (keyword #f "private")) (_o$7090 #t)) (jolt-hash-map _o$7089 _o$7090)))) + (def-var-with-meta! "jolt.backend-scheme" "ffi-types" (let* ((_o$7172 "int") (_o$7173 "int") (_o$7174 "uint") (_o$7175 "unsigned-int") (_o$7176 "long") (_o$7177 "long") (_o$7178 "ulong") (_o$7179 "unsigned-long") (_o$7180 "int64") (_o$7181 "integer-64") (_o$7182 "uint64") (_o$7183 "unsigned-64") (_o$7184 "size_t") (_o$7185 "size_t") (_o$7186 "ssize_t") (_o$7187 "ssize_t") (_o$7188 "iptr") (_o$7189 "iptr") (_o$7190 "uptr") (_o$7191 "uptr") (_o$7192 "double") (_o$7193 "double") (_o$7194 "float") (_o$7195 "float") (_o$7196 "pointer") (_o$7197 "void*") (_o$7198 "void*") (_o$7199 "void*") (_o$7200 "string") (_o$7201 "string") (_o$7202 "void") (_o$7203 "void") (_o$7204 "uint8") (_o$7205 "unsigned-8") (_o$7206 "u8") (_o$7207 "unsigned-8") (_o$7208 "byte") (_o$7209 "unsigned-8") (_o$7210 "char") (_o$7211 "char")) (jolt-hash-map _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)) (let* ((_o$7212 (keyword #f "private")) (_o$7213 #t)) (jolt-hash-map _o$7212 _o$7213)))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "ffi-type->chez" (letrec ((ffi-type->chez (lambda (t) (let fnrec7091 ((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$7092 (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi: unknown foreign type :" t)) (_a$7093 (jolt-hash-map))) (jolt-ex-info _a$7092 _a$7093))))))))) ffi-type->chez))) + (def-var! "jolt.backend-scheme" "ffi-type->chez" (letrec ((ffi-type->chez (lambda (t) (let fnrec7214 ((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$7215 (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi: unknown foreign type :" t)) (_a$7216 (jolt-hash-map))) (jolt-ex-info _a$7215 _a$7216))))))))) ffi-type->chez))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit-ffi-fn" (letrec ((emit-ffi-fn (lambda (node) (let fnrec7094 ((node node)) (let* ((_a$7095 (var-deref "clojure.core" "str")) (_a$7096 "(foreign-procedure ") (_a$7097 (if (jolt-truthy? (jolt-get node (keyword #f "blocking"))) "__collect_safe " jolt-nil)) (_a$7098 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "csym")))) (_a$7099 " (") (_a$7100 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$7101 ") ") (_a$7102 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$7103 ")")) (jolt-invoke _a$7095 _a$7096 _a$7097 _a$7098 _a$7099 _a$7100 _a$7101 _a$7102 _a$7103)))))) emit-ffi-fn))) + (def-var! "jolt.backend-scheme" "emit-ffi-fn" (letrec ((emit-ffi-fn (lambda (node) (let fnrec7217 ((node node)) (let* ((_a$7218 (var-deref "clojure.core" "str")) (_a$7219 "(foreign-procedure ") (_a$7220 (if (jolt-truthy? (jolt-get node (keyword #f "blocking"))) "__collect_safe " jolt-nil)) (_a$7221 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "csym")))) (_a$7222 " (") (_a$7223 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$7224 ") ") (_a$7225 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$7226 ")")) (jolt-invoke _a$7218 _a$7219 _a$7220 _a$7221 _a$7222 _a$7223 _a$7224 _a$7225 _a$7226)))))) emit-ffi-fn))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit-ffi-callable" (letrec ((emit-ffi-callable (lambda (node) (let fnrec7104 ((node node)) (let* ((_a$7105 (var-deref "clojure.core" "str")) (_a$7106 "(jolt-ffi-register-callable! (foreign-callable ") (_a$7107 (if (jolt-truthy? (jolt-get node (keyword #f "collect-safe"))) "__collect_safe " jolt-nil)) (_a$7108 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "fn")))) (_a$7109 " (") (_a$7110 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$7111 ") ") (_a$7112 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$7113 "))")) (jolt-invoke _a$7105 _a$7106 _a$7107 _a$7108 _a$7109 _a$7110 _a$7111 _a$7112 _a$7113)))))) emit-ffi-callable))) + (def-var! "jolt.backend-scheme" "emit-ffi-callable" (letrec ((emit-ffi-callable (lambda (node) (let fnrec7227 ((node node)) (let* ((_a$7228 (var-deref "clojure.core" "str")) (_a$7229 "(jolt-ffi-register-callable! (foreign-callable ") (_a$7230 (if (jolt-truthy? (jolt-get node (keyword #f "collect-safe"))) "__collect_safe " jolt-nil)) (_a$7231 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "fn")))) (_a$7232 " (") (_a$7233 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$7234 ") ") (_a$7235 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$7236 "))")) (jolt-invoke _a$7228 _a$7229 _a$7230 _a$7231 _a$7232 _a$7233 _a$7234 _a$7235 _a$7236)))))) emit-ffi-callable))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit-recur" (letrec ((emit-recur (lambda (node) (let fnrec7114 ((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$7116 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7117 arg-nodes) (_a$7118 (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit") arg-nodes)) (_a$7119 (lambda (as) (let fnrec7115 ((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$7116 _a$7117 _a$7118 _a$7119)))))))) emit-recur))) + (def-var! "jolt.backend-scheme" "emit-recur" (letrec ((emit-recur (lambda (node) (let fnrec7237 ((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$7239 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7240 arg-nodes) (_a$7241 (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit") arg-nodes)) (_a$7242 (lambda (as) (let fnrec7238 ((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$7239 _a$7240 _a$7241 _a$7242)))))))) emit-recur))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "nhint-init" (letrec ((nhint-init (lambda (nh orig munged) (let fnrec7120 ((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))) + (def-var! "jolt.backend-scheme" "nhint-init" (letrec ((nhint-init (lambda (nh orig munged) (let fnrec7243 ((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))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit-arity-clause" (letrec ((emit-arity-clause (lambda (a) (let fnrec7121 ((a a)) (let* ((orig (jolt-get a (keyword #f "params"))) (nh (let* ((_a$7122 (jolt-hash-map)) (_a$7123 (jolt-get a (keyword #f "nhints")))) (jolt-into _a$7122 _a$7123))) (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 fnrec7124 ((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$7125 paramlist) (_o$7126 (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$7125 _o$7126))))))) emit-arity-clause))) + (def-var! "jolt.backend-scheme" "emit-arity-clause" (letrec ((emit-arity-clause (lambda (a) (let fnrec7244 ((a a)) (let* ((orig (jolt-get a (keyword #f "params"))) (nh (let* ((_a$7245 (jolt-hash-map)) (_a$7246 (jolt-get a (keyword #f "nhints")))) (jolt-into _a$7245 _a$7246))) (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 fnrec7247 ((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$7248 paramlist) (_o$7249 (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$7248 _o$7249))))))) emit-arity-clause))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit-fn" (letrec ((emit-fn (lambda (node) (let fnrec7127 ((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$7128 (var-deref "clojure.core" "str")) (_a$7129 "(lambda ") (_a$7130 (jolt-nth c 0)) (_a$7131 " ") (_a$7132 (jolt-nth c 1)) (_a$7133 ")")) (jolt-invoke _a$7128 _a$7129 _a$7130 _a$7131 _a$7132 _a$7133))) (jolt-invoke (var-deref "clojure.core" "str") "(case-lambda " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (c) (let fnrec7134 ((c c)) (let* ((_a$7135 (var-deref "clojure.core" "str")) (_a$7136 "(") (_a$7137 (jolt-nth c 0)) (_a$7138 " ") (_a$7139 (jolt-nth c 1)) (_a$7140 ")")) (jolt-invoke _a$7135 _a$7136 _a$7137 _a$7138 _a$7139 _a$7140)))) 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))) + (def-var! "jolt.backend-scheme" "emit-fn" (letrec ((emit-fn (lambda (node) (let fnrec7250 ((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$7251 (var-deref "clojure.core" "str")) (_a$7252 "(lambda ") (_a$7253 (jolt-nth c 0)) (_a$7254 " ") (_a$7255 (jolt-nth c 1)) (_a$7256 ")")) (jolt-invoke _a$7251 _a$7252 _a$7253 _a$7254 _a$7255 _a$7256))) (jolt-invoke (var-deref "clojure.core" "str") "(case-lambda " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (c) (let fnrec7257 ((c c)) (let* ((_a$7258 (var-deref "clojure.core" "str")) (_a$7259 "(") (_a$7260 (jolt-nth c 0)) (_a$7261 " ") (_a$7262 (jolt-nth c 1)) (_a$7263 ")")) (jolt-invoke _a$7258 _a$7259 _a$7260 _a$7261 _a$7262 _a$7263)))) 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))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "native-op" (letrec ((native-op (lambda (fnode nargs) (let fnrec7141 ((fnode fnode) (nargs nargs)) (let* ((nm (let* ((G__134 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__134 (keyword #f "var")) (if (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) (jolt-get fnode (keyword #f "name")) jolt-nil) (if (jolt= G__134 (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))) + (def-var! "jolt.backend-scheme" "native-op" (letrec ((native-op (lambda (fnode nargs) (let fnrec7264 ((fnode fnode) (nargs nargs)) (let* ((nm (let* ((G__134 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__134 (keyword #f "var")) (if (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) (jolt-get fnode (keyword #f "name")) jolt-nil) (if (jolt= G__134 (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))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "ifn-kind" (letrec ((ifn-kind (lambda (fnode) (let fnrec7142 ((fnode fnode)) (let* ((G__135 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__135 (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__135 (keyword #f "map")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= G__135 (keyword #f "set")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= G__135 (keyword #f "vector")))))) (keyword #f "coll") jolt-nil))))))) ifn-kind))) + (def-var! "jolt.backend-scheme" "ifn-kind" (letrec ((ifn-kind (lambda (fnode) (let fnrec7265 ((fnode fnode)) (let* ((G__135 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__135 (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__135 (keyword #f "map")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= G__135 (keyword #f "set")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= G__135 (keyword #f "vector")))))) (keyword #f "coll") jolt-nil))))))) ifn-kind))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "stdlib-var?" (letrec ((stdlib-var? (lambda (n) (let fnrec7143 ((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?))) + (def-var! "jolt.backend-scheme" "stdlib-var?" (letrec ((stdlib-var? (lambda (n) (let fnrec7266 ((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?))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit-numeric" (letrec ((emit-numeric (lambda (kind nm args order-args) (let fnrec7144 ((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) (let* ((or__26__auto (jolt= nm "inc"))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= nm "unchecked-inc"))) and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(fx1+ " (jolt-first args) ")") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (let* ((or__26__auto (jolt= nm "dec"))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= nm "unchecked-dec"))) and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(fx1- " (jolt-first args) ")") (if (jolt-truthy? (keyword #f "else")) (let* ((op (let* ((G__136 kind)) (if (jolt= G__136 (keyword #f "double")) (jolt-invoke (var-deref "jolt.backend-scheme" "dbl-ops") nm) (if (jolt= G__136 (keyword #f "long")) (jolt-invoke (var-deref "jolt.backend-scheme" "lng-ops") nm) (if (jolt= G__136 (keyword #f "bigdec")) (jolt-invoke (var-deref "jolt.backend-scheme" "bd-ops") nm) (jolt-throw (let* ((_a$7145 (jolt-invoke (var-deref "clojure.core" "str") "No matching clause: " G__136)) (_a$7146 (jolt-hash-map))) (jolt-ex-info _a$7145 _a$7146))))))))) (jolt-invoke order-args (lambda (as) (let fnrec7147 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" op " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")"))))) jolt-nil))))))))) emit-numeric))) + (def-var! "jolt.backend-scheme" "emit-numeric" (letrec ((emit-numeric (lambda (kind nm args order-args) (let fnrec7267 ((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) (let* ((or__26__auto (jolt= nm "inc"))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= nm "unchecked-inc"))) and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(fx1+ " (jolt-first args) ")") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (let* ((or__26__auto (jolt= nm "dec"))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= nm "unchecked-dec"))) and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(fx1- " (jolt-first args) ")") (if (jolt-truthy? (keyword #f "else")) (let* ((op (let* ((G__136 kind)) (if (jolt= G__136 (keyword #f "double")) (jolt-invoke (var-deref "jolt.backend-scheme" "dbl-ops") nm) (if (jolt= G__136 (keyword #f "long")) (jolt-invoke (var-deref "jolt.backend-scheme" "lng-ops") nm) (if (jolt= G__136 (keyword #f "bigdec")) (jolt-invoke (var-deref "jolt.backend-scheme" "bd-ops") nm) (jolt-throw (let* ((_a$7268 (jolt-invoke (var-deref "clojure.core" "str") "No matching clause: " G__136)) (_a$7269 (jolt-hash-map))) (jolt-ex-info _a$7268 _a$7269))))))))) (jolt-invoke order-args (lambda (as) (let fnrec7270 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" op " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")"))))) jolt-nil))))))))) emit-numeric))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "struct-field-index" (letrec ((struct-field-index (lambda (shape kw) (let fnrec7148 ((shape shape) (kw kw)) (if (jolt-truthy? shape) (let* ((i 0)) (let loop7149 ((i i)) (if (>= i (jolt-count shape)) jolt-nil (if (jolt= (jolt-nth shape i) kw) i (if (jolt-truthy? (keyword #f "else")) (loop7149 (jolt-inc i)) jolt-nil))))) jolt-nil))))) struct-field-index))) + (def-var! "jolt.backend-scheme" "struct-field-index" (letrec ((struct-field-index (lambda (shape kw) (let fnrec7271 ((shape shape) (kw kw)) (if (jolt-truthy? shape) (let* ((i 0)) (let loop7272 ((i i)) (if (>= i (jolt-count shape)) jolt-nil (if (jolt= (jolt-nth shape i) kw) i (if (jolt-truthy? (keyword #f "else")) (loop7272 (jolt-inc i)) jolt-nil))))) jolt-nil))))) struct-field-index))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit-invoke" (letrec ((emit-invoke (lambda (node) (let fnrec7150 ((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 fnrec7151 ((build build)) (jolt-invoke (var-deref "jolt.backend-scheme" "ordered-call") arg-nodes args build)))) (defstr (lambda (as) (let fnrec7152 ((as as)) (if (> (jolt-count as) 1) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-nth as 1)) "")))) (invoke (lambda () (let fnrec7153 () (let* ((_a$7155 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7156 (jolt-cons fnode arg-nodes)) (_a$7157 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$7158 (lambda (G__137) (let fnrec7154 ((G__137 G__137)) (let* ((G__138 G__137) (f (jolt-nth G__138 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__138 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$7155 _a$7156 _a$7157 _a$7158)))))) (if (jolt-truthy? (jolt-get node (keyword #f "devirt-type"))) (jolt-invoke order-args (lambda (as) (let fnrec7159 ((as as)) (let* ((r (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_r$"))) (let* ((_a$7160 (var-deref "clojure.core" "str")) (_a$7161 "(let* ((") (_a$7162 r) (_a$7163 " ") (_a$7164 (jolt-first as)) (_a$7165 ")) ") (_a$7166 "((devirt-resolve ") (_a$7167 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-type")))) (_a$7168 " ") (_a$7169 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-proto")))) (_a$7170 " ") (_a$7171 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-method")))) (_a$7172 " ") (_a$7173 r) (_a$7174 ") ") (_a$7175 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-cons r (jolt-rest as)))) (_a$7176 "))")) (jolt-invoke _a$7160 _a$7161 _a$7162 _a$7163 _a$7164 _a$7165 _a$7166 _a$7167 _a$7168 _a$7169 _a$7170 _a$7171 _a$7172 _a$7173 _a$7174 _a$7175 _a$7176)))))) (if (jolt-truthy? (jolt-get node (keyword #f "num-kind"))) (let* ((_a$7177 (var-deref "jolt.backend-scheme" "emit-numeric")) (_a$7178 (jolt-get node (keyword #f "num-kind"))) (_a$7179 (jolt-get fnode (keyword #f "name"))) (_a$7180 args) (_a$7181 order-args)) (jolt-invoke _a$7177 _a$7178 _a$7179 _a$7180 _a$7181)) (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 fnrec7182 ((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$7183 (var-deref "jolt.backend-scheme" "struct-field-index")) (_a$7184 (jolt-get recv (keyword #f "shape"))) (_a$7185 (jolt-get fnode (keyword #f "val")))) (jolt-invoke _a$7183 _a$7184 _a$7185)) jolt-nil))) (if (jolt-truthy? idx) (jolt-invoke order-args (lambda (as) (let fnrec7186 ((as as)) (let* ((_a$7187 (var-deref "clojure.core" "str")) (_a$7188 "(jrec-field-at ") (_a$7189 (jolt-first as)) (_a$7190 " ") (_a$7191 idx) (_a$7192 " ") (_a$7193 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode)) (_a$7194 ")")) (jolt-invoke _a$7187 _a$7188 _a$7189 _a$7190 _a$7191 _a$7192 _a$7193 _a$7194))))) (jolt-invoke order-args (lambda (as) (let fnrec7195 ((as as)) (let* ((_a$7196 (var-deref "clojure.core" "str")) (_a$7197 "(jolt-get ") (_a$7198 (jolt-first as)) (_a$7199 " ") (_a$7200 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode)) (_a$7201 (jolt-invoke defstr as)) (_a$7202 ")")) (jolt-invoke _a$7196 _a$7197 _a$7198 _a$7199 _a$7200 _a$7201 _a$7202))))))) (if (jolt= kind (keyword #f "coll")) (let* ((_a$7204 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7205 (jolt-cons fnode arg-nodes)) (_a$7206 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$7207 (lambda (G__139) (let fnrec7203 ((G__139 G__139)) (let* ((G__140 G__139) (c (jolt-nth G__140 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__140 1))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-get " c " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")")))))) (jolt-invoke _a$7204 _a$7205 _a$7206 _a$7207)) (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$7214 (let* ((_a$7208 (var-deref "clojure.core" "str")) (_a$7209 "emit: unsupported stdlib fn `") (_a$7210 (jolt-get fnode (keyword #f "ns"))) (_a$7211 "/") (_a$7212 (jolt-get fnode (keyword #f "name"))) (_a$7213 "` (no core on Chez yet)")) (jolt-invoke _a$7208 _a$7209 _a$7210 _a$7211 _a$7212 _a$7213))) (_a$7215 (jolt-hash-map))) (jolt-ex-info _a$7214 _a$7215))) (if (jolt= (keyword #f "host-static") (jolt-get fnode (keyword #f "op"))) (jolt-invoke order-args (lambda (as) (let fnrec7216 ((as as)) (let* ((_a$7217 (var-deref "clojure.core" "str")) (_a$7218 "(host-static-call ") (_a$7219 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "class")))) (_a$7220 " ") (_a$7221 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "member")))) (_a$7222 (if (jolt-empty? as) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)))) (_a$7223 ")")) (jolt-invoke _a$7217 _a$7218 _a$7219 _a$7220 _a$7221 _a$7222 _a$7223))))) (if (jolt= (keyword #f "host") (jolt-get fnode (keyword #f "op"))) (jolt-throw (let* ((_a$7224 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host call `" (jolt-get fnode (keyword #f "name")) "`")) (_a$7225 (jolt-hash-map))) (jolt-ex-info _a$7224 _a$7225))) (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 fnrec7226 ((as as)) (let* ((_a$7227 (var-deref "clojure.core" "str")) (_a$7228 "(") (_a$7229 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get fnode (keyword #f "name")))) (_a$7230 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$7231 ")")) (jolt-invoke _a$7227 _a$7228 _a$7229 _a$7230 _a$7231))))) (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$7232 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$7233 (jolt-get fnode (keyword #f "ns"))) (_a$7234 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7232 _a$7233 _a$7234)))) (if (jolt-truthy? and__25__auto) (let* ((_a$7235 (var-deref "jolt.backend-scheme" "direct-link-fn?")) (_a$7236 (jolt-get fnode (keyword #f "ns"))) (_a$7237 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7235 _a$7236 _a$7237)) and__25__auto)) and__25__auto))) (jolt-invoke order-args (lambda (as) (let fnrec7238 ((as as)) (let* ((_a$7242 (var-deref "clojure.core" "str")) (_a$7243 "(") (_a$7244 (let* ((_a$7239 (var-deref "jolt.backend-scheme" "dl-name")) (_a$7240 (jolt-get fnode (keyword #f "ns"))) (_a$7241 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7239 _a$7240 _a$7241))) (_a$7245 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$7246 ")")) (jolt-invoke _a$7242 _a$7243 _a$7244 _a$7245 _a$7246))))) (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))) + (def-var! "jolt.backend-scheme" "emit-invoke" (letrec ((emit-invoke (lambda (node) (let fnrec7273 ((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 fnrec7274 ((build build)) (jolt-invoke (var-deref "jolt.backend-scheme" "ordered-call") arg-nodes args build)))) (defstr (lambda (as) (let fnrec7275 ((as as)) (if (> (jolt-count as) 1) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-nth as 1)) "")))) (invoke (lambda () (let fnrec7276 () (let* ((_a$7278 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7279 (jolt-cons fnode arg-nodes)) (_a$7280 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$7281 (lambda (G__137) (let fnrec7277 ((G__137 G__137)) (let* ((G__138 G__137) (f (jolt-nth G__138 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__138 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$7278 _a$7279 _a$7280 _a$7281)))))) (if (jolt-truthy? (jolt-get node (keyword #f "devirt-type"))) (jolt-invoke order-args (lambda (as) (let fnrec7282 ((as as)) (let* ((r (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_r$"))) (let* ((_a$7283 (var-deref "clojure.core" "str")) (_a$7284 "(let* ((") (_a$7285 r) (_a$7286 " ") (_a$7287 (jolt-first as)) (_a$7288 ")) ") (_a$7289 "((devirt-resolve ") (_a$7290 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-type")))) (_a$7291 " ") (_a$7292 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-proto")))) (_a$7293 " ") (_a$7294 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-method")))) (_a$7295 " ") (_a$7296 r) (_a$7297 ") ") (_a$7298 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-cons r (jolt-rest as)))) (_a$7299 "))")) (jolt-invoke _a$7283 _a$7284 _a$7285 _a$7286 _a$7287 _a$7288 _a$7289 _a$7290 _a$7291 _a$7292 _a$7293 _a$7294 _a$7295 _a$7296 _a$7297 _a$7298 _a$7299)))))) (if (jolt-truthy? (jolt-get node (keyword #f "num-kind"))) (let* ((_a$7300 (var-deref "jolt.backend-scheme" "emit-numeric")) (_a$7301 (jolt-get node (keyword #f "num-kind"))) (_a$7302 (jolt-get fnode (keyword #f "name"))) (_a$7303 args) (_a$7304 order-args)) (jolt-invoke _a$7300 _a$7301 _a$7302 _a$7303 _a$7304)) (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 fnrec7305 ((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$7306 (var-deref "jolt.backend-scheme" "struct-field-index")) (_a$7307 (jolt-get recv (keyword #f "shape"))) (_a$7308 (jolt-get fnode (keyword #f "val")))) (jolt-invoke _a$7306 _a$7307 _a$7308)) jolt-nil))) (if (jolt-truthy? idx) (jolt-invoke order-args (lambda (as) (let fnrec7309 ((as as)) (let* ((_a$7310 (var-deref "clojure.core" "str")) (_a$7311 "(jrec-field-at ") (_a$7312 (jolt-first as)) (_a$7313 " ") (_a$7314 idx) (_a$7315 " ") (_a$7316 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode)) (_a$7317 ")")) (jolt-invoke _a$7310 _a$7311 _a$7312 _a$7313 _a$7314 _a$7315 _a$7316 _a$7317))))) (jolt-invoke order-args (lambda (as) (let fnrec7318 ((as as)) (let* ((_a$7319 (var-deref "clojure.core" "str")) (_a$7320 "(jolt-get ") (_a$7321 (jolt-first as)) (_a$7322 " ") (_a$7323 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode)) (_a$7324 (jolt-invoke defstr as)) (_a$7325 ")")) (jolt-invoke _a$7319 _a$7320 _a$7321 _a$7322 _a$7323 _a$7324 _a$7325))))))) (if (jolt= kind (keyword #f "coll")) (let* ((_a$7327 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7328 (jolt-cons fnode arg-nodes)) (_a$7329 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$7330 (lambda (G__139) (let fnrec7326 ((G__139 G__139)) (let* ((G__140 G__139) (c (jolt-nth G__140 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__140 1))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-get " c " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")")))))) (jolt-invoke _a$7327 _a$7328 _a$7329 _a$7330)) (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$7337 (let* ((_a$7331 (var-deref "clojure.core" "str")) (_a$7332 "emit: unsupported stdlib fn `") (_a$7333 (jolt-get fnode (keyword #f "ns"))) (_a$7334 "/") (_a$7335 (jolt-get fnode (keyword #f "name"))) (_a$7336 "` (no core on Chez yet)")) (jolt-invoke _a$7331 _a$7332 _a$7333 _a$7334 _a$7335 _a$7336))) (_a$7338 (jolt-hash-map))) (jolt-ex-info _a$7337 _a$7338))) (if (jolt= (keyword #f "host-static") (jolt-get fnode (keyword #f "op"))) (jolt-invoke order-args (lambda (as) (let fnrec7339 ((as as)) (let* ((_a$7340 (var-deref "clojure.core" "str")) (_a$7341 "(host-static-call ") (_a$7342 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "class")))) (_a$7343 " ") (_a$7344 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "member")))) (_a$7345 (if (jolt-empty? as) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)))) (_a$7346 ")")) (jolt-invoke _a$7340 _a$7341 _a$7342 _a$7343 _a$7344 _a$7345 _a$7346))))) (if (jolt= (keyword #f "host") (jolt-get fnode (keyword #f "op"))) (jolt-throw (let* ((_a$7347 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host call `" (jolt-get fnode (keyword #f "name")) "`")) (_a$7348 (jolt-hash-map))) (jolt-ex-info _a$7347 _a$7348))) (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 fnrec7349 ((as as)) (let* ((_a$7350 (var-deref "clojure.core" "str")) (_a$7351 "(") (_a$7352 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get fnode (keyword #f "name")))) (_a$7353 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$7354 ")")) (jolt-invoke _a$7350 _a$7351 _a$7352 _a$7353 _a$7354))))) (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$7355 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$7356 (jolt-get fnode (keyword #f "ns"))) (_a$7357 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7355 _a$7356 _a$7357)))) (if (jolt-truthy? and__25__auto) (let* ((_a$7358 (var-deref "jolt.backend-scheme" "direct-link-fn?")) (_a$7359 (jolt-get fnode (keyword #f "ns"))) (_a$7360 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7358 _a$7359 _a$7360)) and__25__auto)) and__25__auto))) (jolt-invoke order-args (lambda (as) (let fnrec7361 ((as as)) (let* ((_a$7365 (var-deref "clojure.core" "str")) (_a$7366 "(") (_a$7367 (let* ((_a$7362 (var-deref "jolt.backend-scheme" "dl-name")) (_a$7363 (jolt-get fnode (keyword #f "ns"))) (_a$7364 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7362 _a$7363 _a$7364))) (_a$7368 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$7369 ")")) (jolt-invoke _a$7365 _a$7366 _a$7367 _a$7368 _a$7369))))) (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))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit-try" (letrec ((emit-try (lambda (node) (let fnrec7247 ((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$7248 (var-deref "clojure.core" "str")) (_a$7249 "(guard (") (_a$7250 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") cs)) (_a$7251 " (else ") (_a$7252 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "catch-body")))) (_a$7253 ")) ") (_a$7254 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$7255 ")")) (jolt-invoke _a$7248 _a$7249 _a$7250 _a$7251 _a$7252 _a$7253 _a$7254 _a$7255))) (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))) + (def-var! "jolt.backend-scheme" "emit-try" (letrec ((emit-try (lambda (node) (let fnrec7370 ((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$7371 (var-deref "clojure.core" "str")) (_a$7372 "(guard (") (_a$7373 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") cs)) (_a$7374 " (else ") (_a$7375 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "catch-body")))) (_a$7376 ")) ") (_a$7377 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$7378 ")")) (jolt-invoke _a$7371 _a$7372 _a$7373 _a$7374 _a$7375 _a$7376 _a$7377 _a$7378))) (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))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "returns-scheme-bool?" (letrec ((returns-scheme-bool? (case-lambda ((node) (let fnrec7256 ((node node)) (returns-scheme-bool? node (jolt-hash-set)))) ((node bools) (let fnrec7257 ((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$7258 (var-deref "jolt.backend-scheme" "native-op")) (_a$7259 (jolt-get node (keyword #f "fn"))) (_a$7260 (jolt-count (jolt-get node (keyword #f "args"))))) (jolt-invoke _a$7258 _a$7259 _a$7260)))) (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$7262 (lambda (s b) (let fnrec7261 ((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$7263 bools) (_a$7264 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$7262 _a$7263 _a$7264)))) (returns-scheme-bool? (jolt-get node (keyword #f "body")) bools_PRIME_)) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))))))))) returns-scheme-bool?))) + (def-var! "jolt.backend-scheme" "returns-scheme-bool?" (letrec ((returns-scheme-bool? (case-lambda ((node) (let fnrec7379 ((node node)) (returns-scheme-bool? node (jolt-hash-set)))) ((node bools) (let fnrec7380 ((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$7381 (var-deref "jolt.backend-scheme" "native-op")) (_a$7382 (jolt-get node (keyword #f "fn"))) (_a$7383 (jolt-count (jolt-get node (keyword #f "args"))))) (jolt-invoke _a$7381 _a$7382 _a$7383)))) (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$7385 (lambda (s b) (let fnrec7384 ((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$7386 bools) (_a$7387 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$7385 _a$7386 _a$7387)))) (returns-scheme-bool? (jolt-get node (keyword #f "body")) bools_PRIME_)) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))))))))) returns-scheme-bool?))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit" (letrec ((emit (lambda (node) (let fnrec7265 ((node node)) (let* ((G__141 (jolt-get node (keyword #f "op")))) (if (jolt= G__141 (keyword #f "const")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") (jolt-get node (keyword #f "val"))) (if (jolt= G__141 (keyword #f "local")) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get node (keyword #f "name"))) (if (jolt= G__141 (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$7266 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$7267 (jolt-get node (keyword #f "ns"))) (_a$7268 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$7266 _a$7267 _a$7268))) (let* ((_a$7269 (var-deref "jolt.backend-scheme" "dl-name")) (_a$7270 (jolt-get node (keyword #f "ns"))) (_a$7271 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$7269 _a$7270 _a$7271)) (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$7278 (let* ((_a$7272 (var-deref "clojure.core" "str")) (_a$7273 "emit: unsupported stdlib ref `") (_a$7274 (jolt-get node (keyword #f "ns"))) (_a$7275 "/") (_a$7276 (jolt-get node (keyword #f "name"))) (_a$7277 "` (no core on Chez yet)")) (jolt-invoke _a$7272 _a$7273 _a$7274 _a$7275 _a$7276 _a$7277))) (_a$7279 (jolt-hash-map))) (jolt-ex-info _a$7278 _a$7279))) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$7280 (var-deref "clojure.core" "str")) (_a$7281 "(var-deref ") (_a$7282 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7283 " ") (_a$7284 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7285 ")")) (jolt-invoke _a$7280 _a$7281 _a$7282 _a$7283 _a$7284 _a$7285)) jolt-nil))))) (if (jolt= G__141 (keyword #f "the-var")) (let* ((_a$7286 (var-deref "clojure.core" "str")) (_a$7287 "(jolt-var ") (_a$7288 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7289 " ") (_a$7290 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7291 ")")) (jolt-invoke _a$7286 _a$7287 _a$7288 _a$7289 _a$7290 _a$7291)) (if (jolt= G__141 (keyword #f "set-var")) (let* ((_a$7292 (var-deref "clojure.core" "str")) (_a$7293 "(jolt-var-set ") (_a$7294 (emit (jolt-get node (keyword #f "the-var")))) (_a$7295 " ") (_a$7296 (emit (jolt-get node (keyword #f "val")))) (_a$7297 ")")) (jolt-invoke _a$7292 _a$7293 _a$7294 _a$7295 _a$7296 _a$7297)) (if (jolt= G__141 (keyword #f "set-field")) (let* ((_a$7298 (var-deref "clojure.core" "str")) (_a$7299 "(jolt-set-field! ") (_a$7300 (emit (jolt-get node (keyword #f "obj")))) (_a$7301 " (keyword #f ") (_a$7302 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "field")))) (_a$7303 ") ") (_a$7304 (emit (jolt-get node (keyword #f "val")))) (_a$7305 ")")) (jolt-invoke _a$7298 _a$7299 _a$7300 _a$7301 _a$7302 _a$7303 _a$7304 _a$7305)) (if (jolt= G__141 (keyword #f "defmacro")) (let* ((_a$7306 (var-deref "clojure.core" "str")) (_a$7307 "(begin (def-var! ") (_a$7308 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7309 " ") (_a$7310 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7311 " ") (_a$7312 (emit (jolt-get node (keyword #f "fn")))) (_a$7313 ") (mark-macro! ") (_a$7314 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7315 " ") (_a$7316 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7317 ") jolt-nil)")) (jolt-invoke _a$7306 _a$7307 _a$7308 _a$7309 _a$7310 _a$7311 _a$7312 _a$7313 _a$7314 _a$7315 _a$7316 _a$7317)) (if (jolt= G__141 (keyword #f "host")) (jolt-throw (let* ((_a$7318 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host ref `" (jolt-get node (keyword #f "name")) "`")) (_a$7319 (jolt-hash-map))) (jolt-ex-info _a$7318 _a$7319))) (if (jolt= G__141 (keyword #f "host-static")) (let* ((_a$7320 (var-deref "clojure.core" "str")) (_a$7321 "(host-static-ref ") (_a$7322 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$7323 " ") (_a$7324 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "member")))) (_a$7325 ")")) (jolt-invoke _a$7320 _a$7321 _a$7322 _a$7323 _a$7324 _a$7325)) (if (jolt= G__141 (keyword #f "host-new")) (let* ((_a$7326 (var-deref "clojure.core" "str")) (_a$7327 "(host-new ") (_a$7328 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$7329 (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$7330 ")")) (jolt-invoke _a$7326 _a$7327 _a$7328 _a$7329 _a$7330)) (if (jolt= G__141 (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$7331 (var-deref "clojure.core" "str")) (_a$7332 "(if ") (_a$7333 t) (_a$7334 " ") (_a$7335 (emit (jolt-get node (keyword #f "then")))) (_a$7336 " ") (_a$7337 (emit (jolt-get node (keyword #f "else")))) (_a$7338 ")")) (jolt-invoke _a$7331 _a$7332 _a$7333 _a$7334 _a$7335 _a$7336 _a$7337 _a$7338))) (if (jolt= G__141 (keyword #f "do")) (let* ((_a$7339 (var-deref "clojure.core" "str")) (_a$7340 "(begin ") (_a$7341 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit (jolt-get node (keyword #f "statements"))))) (_a$7342 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$7343 (emit (jolt-get node (keyword #f "ret")))) (_a$7344 ")")) (jolt-invoke _a$7339 _a$7340 _a$7341 _a$7342 _a$7343 _a$7344)) (if (jolt= G__141 (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-invoke") node) (if (jolt= G__141 (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__141 (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__141 (keyword #f "map")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-hash-map" (let* ((_a$7348 (var-deref "clojure.core" "mapcat")) (_a$7349 (lambda (p) (let fnrec7345 ((p p)) (let* ((_o$7346 (emit (jolt-nth p 0))) (_o$7347 (emit (jolt-nth p 1)))) (jolt-vector _o$7346 _o$7347))))) (_a$7350 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$7348 _a$7349 _a$7350))) (if (jolt= G__141 (keyword #f "quote")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get node (keyword #f "form"))) (if (jolt= G__141 (keyword #f "throw")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-throw " (emit (jolt-get node (keyword #f "expr"))) ")") (if (jolt= G__141 (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__141 (keyword #f "try")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-try") node) (if (jolt= G__141 (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__141 (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__141 (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__141 (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__141 (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__141 (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$7351 (var-deref "clojure.core" "str")) (_a$7352 "(jolt-host-call ") (_a$7353 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$7354 " ") (_a$7355 target) (_a$7356 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$7357 ")")) (jolt-invoke _a$7351 _a$7352 _a$7353 _a$7354 _a$7355 _a$7356 _a$7357)) (let* ((_a$7358 (var-deref "clojure.core" "str")) (_a$7359 "(record-method-dispatch ") (_a$7360 target) (_a$7361 " ") (_a$7362 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$7363 " (jolt-vector") (_a$7364 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$7365 "))")) (jolt-invoke _a$7358 _a$7359 _a$7360 _a$7361 _a$7362 _a$7363 _a$7364 _a$7365)))) (if (jolt= G__141 (keyword #f "let")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-let") node) (if (jolt= G__141 (keyword #f "loop")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-loop") node) (if (jolt= G__141 (keyword #f "recur")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-recur") node) (if (jolt= G__141 (keyword #f "ffi-fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-fn") node) (if (jolt= G__141 (keyword #f "ffi-callable")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-callable") node) (if (jolt= G__141 (keyword #f "fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-fn") node) (if (jolt= G__141 (keyword #f "def")) (if (jolt-truthy? (jolt-get node (keyword #f "no-init"))) (let* ((_a$7366 (var-deref "clojure.core" "str")) (_a$7367 "(declare-var! ") (_a$7368 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7369 " ") (_a$7370 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7371 ")")) (jolt-invoke _a$7366 _a$7367 _a$7368 _a$7369 _a$7370 _a$7371)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$7372 (var-deref "clojure.core" "str")) (_a$7373 "(def-var-with-meta! ") (_a$7374 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7375 " ") (_a$7376 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7377 " ") (_a$7378 (emit (jolt-get node (keyword #f "init")))) (_a$7379 " ") (_a$7380 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$7381 ")")) (jolt-invoke _a$7372 _a$7373 _a$7374 _a$7375 _a$7376 _a$7377 _a$7378 _a$7379 _a$7380 _a$7381)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$7382 (var-deref "clojure.core" "str")) (_a$7383 "(def-var! ") (_a$7384 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7385 " ") (_a$7386 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7387 " ") (_a$7388 (emit (jolt-get node (keyword #f "init")))) (_a$7389 ")")) (jolt-invoke _a$7382 _a$7383 _a$7384 _a$7385 _a$7386 _a$7387 _a$7388 _a$7389)) jolt-nil))) (jolt-throw (let* ((_a$7390 (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$7391 (jolt-hash-map))) (jolt-ex-info _a$7390 _a$7391))))))))))))))))))))))))))))))))))))))))) emit))) + (def-var! "jolt.backend-scheme" "emit" (letrec ((emit (lambda (node) (let fnrec7388 ((node node)) (let* ((G__141 (jolt-get node (keyword #f "op")))) (if (jolt= G__141 (keyword #f "const")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") (jolt-get node (keyword #f "val"))) (if (jolt= G__141 (keyword #f "local")) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get node (keyword #f "name"))) (if (jolt= G__141 (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$7389 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$7390 (jolt-get node (keyword #f "ns"))) (_a$7391 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$7389 _a$7390 _a$7391))) (let* ((_a$7392 (var-deref "jolt.backend-scheme" "dl-name")) (_a$7393 (jolt-get node (keyword #f "ns"))) (_a$7394 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$7392 _a$7393 _a$7394)) (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$7401 (let* ((_a$7395 (var-deref "clojure.core" "str")) (_a$7396 "emit: unsupported stdlib ref `") (_a$7397 (jolt-get node (keyword #f "ns"))) (_a$7398 "/") (_a$7399 (jolt-get node (keyword #f "name"))) (_a$7400 "` (no core on Chez yet)")) (jolt-invoke _a$7395 _a$7396 _a$7397 _a$7398 _a$7399 _a$7400))) (_a$7402 (jolt-hash-map))) (jolt-ex-info _a$7401 _a$7402))) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$7403 (var-deref "clojure.core" "str")) (_a$7404 "(var-deref ") (_a$7405 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7406 " ") (_a$7407 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7408 ")")) (jolt-invoke _a$7403 _a$7404 _a$7405 _a$7406 _a$7407 _a$7408)) jolt-nil))))) (if (jolt= G__141 (keyword #f "the-var")) (let* ((_a$7409 (var-deref "clojure.core" "str")) (_a$7410 "(jolt-var ") (_a$7411 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7412 " ") (_a$7413 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7414 ")")) (jolt-invoke _a$7409 _a$7410 _a$7411 _a$7412 _a$7413 _a$7414)) (if (jolt= G__141 (keyword #f "set-var")) (let* ((_a$7415 (var-deref "clojure.core" "str")) (_a$7416 "(jolt-var-set ") (_a$7417 (emit (jolt-get node (keyword #f "the-var")))) (_a$7418 " ") (_a$7419 (emit (jolt-get node (keyword #f "val")))) (_a$7420 ")")) (jolt-invoke _a$7415 _a$7416 _a$7417 _a$7418 _a$7419 _a$7420)) (if (jolt= G__141 (keyword #f "set-field")) (let* ((_a$7421 (var-deref "clojure.core" "str")) (_a$7422 "(jolt-set-field! ") (_a$7423 (emit (jolt-get node (keyword #f "obj")))) (_a$7424 " (keyword #f ") (_a$7425 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "field")))) (_a$7426 ") ") (_a$7427 (emit (jolt-get node (keyword #f "val")))) (_a$7428 ")")) (jolt-invoke _a$7421 _a$7422 _a$7423 _a$7424 _a$7425 _a$7426 _a$7427 _a$7428)) (if (jolt= G__141 (keyword #f "defmacro")) (let* ((_a$7429 (var-deref "clojure.core" "str")) (_a$7430 "(begin (def-var! ") (_a$7431 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7432 " ") (_a$7433 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7434 " ") (_a$7435 (emit (jolt-get node (keyword #f "fn")))) (_a$7436 ") (mark-macro! ") (_a$7437 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7438 " ") (_a$7439 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7440 ") jolt-nil)")) (jolt-invoke _a$7429 _a$7430 _a$7431 _a$7432 _a$7433 _a$7434 _a$7435 _a$7436 _a$7437 _a$7438 _a$7439 _a$7440)) (if (jolt= G__141 (keyword #f "host")) (jolt-throw (let* ((_a$7441 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host ref `" (jolt-get node (keyword #f "name")) "`")) (_a$7442 (jolt-hash-map))) (jolt-ex-info _a$7441 _a$7442))) (if (jolt= G__141 (keyword #f "host-static")) (let* ((_a$7443 (var-deref "clojure.core" "str")) (_a$7444 "(host-static-ref ") (_a$7445 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$7446 " ") (_a$7447 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "member")))) (_a$7448 ")")) (jolt-invoke _a$7443 _a$7444 _a$7445 _a$7446 _a$7447 _a$7448)) (if (jolt= G__141 (keyword #f "host-new")) (let* ((_a$7449 (var-deref "clojure.core" "str")) (_a$7450 "(host-new ") (_a$7451 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$7452 (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$7453 ")")) (jolt-invoke _a$7449 _a$7450 _a$7451 _a$7452 _a$7453)) (if (jolt= G__141 (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$7454 (var-deref "clojure.core" "str")) (_a$7455 "(if ") (_a$7456 t) (_a$7457 " ") (_a$7458 (emit (jolt-get node (keyword #f "then")))) (_a$7459 " ") (_a$7460 (emit (jolt-get node (keyword #f "else")))) (_a$7461 ")")) (jolt-invoke _a$7454 _a$7455 _a$7456 _a$7457 _a$7458 _a$7459 _a$7460 _a$7461))) (if (jolt= G__141 (keyword #f "do")) (let* ((_a$7462 (var-deref "clojure.core" "str")) (_a$7463 "(begin ") (_a$7464 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit (jolt-get node (keyword #f "statements"))))) (_a$7465 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$7466 (emit (jolt-get node (keyword #f "ret")))) (_a$7467 ")")) (jolt-invoke _a$7462 _a$7463 _a$7464 _a$7465 _a$7466 _a$7467)) (if (jolt= G__141 (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-invoke") node) (if (jolt= G__141 (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__141 (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__141 (keyword #f "map")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-hash-map" (let* ((_a$7471 (var-deref "clojure.core" "mapcat")) (_a$7472 (lambda (p) (let fnrec7468 ((p p)) (let* ((_o$7469 (emit (jolt-nth p 0))) (_o$7470 (emit (jolt-nth p 1)))) (jolt-vector _o$7469 _o$7470))))) (_a$7473 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$7471 _a$7472 _a$7473))) (if (jolt= G__141 (keyword #f "quote")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get node (keyword #f "form"))) (if (jolt= G__141 (keyword #f "throw")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-throw " (emit (jolt-get node (keyword #f "expr"))) ")") (if (jolt= G__141 (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__141 (keyword #f "try")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-try") node) (if (jolt= G__141 (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__141 (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__141 (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__141 (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__141 (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__141 (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$7474 (var-deref "clojure.core" "str")) (_a$7475 "(jolt-host-call ") (_a$7476 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$7477 " ") (_a$7478 target) (_a$7479 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$7480 ")")) (jolt-invoke _a$7474 _a$7475 _a$7476 _a$7477 _a$7478 _a$7479 _a$7480)) (let* ((_a$7481 (var-deref "clojure.core" "str")) (_a$7482 "(record-method-dispatch ") (_a$7483 target) (_a$7484 " ") (_a$7485 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$7486 " (jolt-vector") (_a$7487 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$7488 "))")) (jolt-invoke _a$7481 _a$7482 _a$7483 _a$7484 _a$7485 _a$7486 _a$7487 _a$7488)))) (if (jolt= G__141 (keyword #f "let")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-let") node) (if (jolt= G__141 (keyword #f "loop")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-loop") node) (if (jolt= G__141 (keyword #f "recur")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-recur") node) (if (jolt= G__141 (keyword #f "ffi-fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-fn") node) (if (jolt= G__141 (keyword #f "ffi-callable")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-callable") node) (if (jolt= G__141 (keyword #f "fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-fn") node) (if (jolt= G__141 (keyword #f "def")) (if (jolt-truthy? (jolt-get node (keyword #f "no-init"))) (let* ((_a$7489 (var-deref "clojure.core" "str")) (_a$7490 "(declare-var! ") (_a$7491 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7492 " ") (_a$7493 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7494 ")")) (jolt-invoke _a$7489 _a$7490 _a$7491 _a$7492 _a$7493 _a$7494)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$7495 (var-deref "clojure.core" "str")) (_a$7496 "(def-var-with-meta! ") (_a$7497 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7498 " ") (_a$7499 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7500 " ") (_a$7501 (emit (jolt-get node (keyword #f "init")))) (_a$7502 " ") (_a$7503 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$7504 ")")) (jolt-invoke _a$7495 _a$7496 _a$7497 _a$7498 _a$7499 _a$7500 _a$7501 _a$7502 _a$7503 _a$7504)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$7505 (var-deref "clojure.core" "str")) (_a$7506 "(def-var! ") (_a$7507 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7508 " ") (_a$7509 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7510 " ") (_a$7511 (emit (jolt-get node (keyword #f "init")))) (_a$7512 ")")) (jolt-invoke _a$7505 _a$7506 _a$7507 _a$7508 _a$7509 _a$7510 _a$7511 _a$7512)) jolt-nil))) (jolt-throw (let* ((_a$7513 (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$7514 (jolt-hash-map))) (jolt-ex-info _a$7513 _a$7514))))))))))))))))))))))))))))))))))))))))) emit))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "dl-opt-out?" (letrec ((dl-opt-out? (lambda (m) (let fnrec7392 ((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?))) + (def-var! "jolt.backend-scheme" "dl-opt-out?" (letrec ((dl-opt-out? (lambda (m) (let fnrec7515 ((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?))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit-top-form" (letrec ((emit-top-form (lambda (node) (let fnrec7393 ((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$7394 (var-deref "clojure.core" "str")) (_a$7395 "(begin ") (_a$7396 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-top-form (jolt-get node (keyword #f "statements"))))) (_a$7397 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$7398 (emit-top-form (jolt-get node (keyword #f "ret")))) (_a$7399 ")")) (jolt-invoke _a$7394 _a$7395 _a$7396 _a$7397 _a$7398 _a$7399)) (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$7400 (var-deref "clojure.core" "str")) (_a$7401 " (jolt-register-source! ") (_a$7402 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") frame-name)) (_a$7403 " ") (_a$7404 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$7405 " ") (_a$7406 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7407 " ") (_a$7408 (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$7409 " ") (_a$7410 (let* ((or__26__auto (jolt-get pos (keyword #f "line")))) (if (jolt-truthy? or__26__auto) or__26__auto 0))) (_a$7411 ")")) (jolt-invoke _a$7400 _a$7401 _a$7402 _a$7403 _a$7404 _a$7405 _a$7406 _a$7407 _a$7408 _a$7409 _a$7410 _a$7411)) 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* ((init (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "init"))))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$7412 (var-deref "clojure.core" "str")) (_a$7413 "(begin (define ") (_a$7414 b) (_a$7415 " ") (_a$7416 init) (_a$7417 ") (def-var-with-meta! ") (_a$7418 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$7419 " ") (_a$7420 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7421 " ") (_a$7422 b) (_a$7423 " ") (_a$7424 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$7425 ")") (_a$7426 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$7427 ")")) (jolt-invoke _a$7412 _a$7413 _a$7414 _a$7415 _a$7416 _a$7417 _a$7418 _a$7419 _a$7420 _a$7421 _a$7422 _a$7423 _a$7424 _a$7425 _a$7426 _a$7427)) (let* ((_a$7428 (var-deref "clojure.core" "str")) (_a$7429 "(begin (define ") (_a$7430 b) (_a$7431 " ") (_a$7432 init) (_a$7433 ") (def-var! ") (_a$7434 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$7435 " ") (_a$7436 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7437 " ") (_a$7438 b) (_a$7439 ")") (_a$7440 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$7441 ")")) (jolt-invoke _a$7428 _a$7429 _a$7430 _a$7431 _a$7432 _a$7433 _a$7434 _a$7435 _a$7436 _a$7437 _a$7438 _a$7439 _a$7440 _a$7441)))))) (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 fnrec7516 ((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$7517 (var-deref "clojure.core" "str")) (_a$7518 "(begin ") (_a$7519 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-top-form (jolt-get node (keyword #f "statements"))))) (_a$7520 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$7521 (emit-top-form (jolt-get node (keyword #f "ret")))) (_a$7522 ")")) (jolt-invoke _a$7517 _a$7518 _a$7519 _a$7520 _a$7521 _a$7522)) (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$7523 (var-deref "clojure.core" "str")) (_a$7524 " (jolt-register-source! ") (_a$7525 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") frame-name)) (_a$7526 " ") (_a$7527 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$7528 " ") (_a$7529 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7530 " ") (_a$7531 (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$7532 " ") (_a$7533 (let* ((or__26__auto (jolt-get pos (keyword #f "line")))) (if (jolt-truthy? or__26__auto) or__26__auto 0))) (_a$7534 ")")) (jolt-invoke _a$7523 _a$7524 _a$7525 _a$7526 _a$7527 _a$7528 _a$7529 _a$7530 _a$7531 _a$7532 _a$7533 _a$7534)) 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* ((init (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "init"))))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$7535 (var-deref "clojure.core" "str")) (_a$7536 "(begin (define ") (_a$7537 b) (_a$7538 " ") (_a$7539 init) (_a$7540 ") (def-var-with-meta! ") (_a$7541 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$7542 " ") (_a$7543 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7544 " ") (_a$7545 b) (_a$7546 " ") (_a$7547 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$7548 ")") (_a$7549 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$7550 ")")) (jolt-invoke _a$7535 _a$7536 _a$7537 _a$7538 _a$7539 _a$7540 _a$7541 _a$7542 _a$7543 _a$7544 _a$7545 _a$7546 _a$7547 _a$7548 _a$7549 _a$7550)) (let* ((_a$7551 (var-deref "clojure.core" "str")) (_a$7552 "(begin (define ") (_a$7553 b) (_a$7554 " ") (_a$7555 init) (_a$7556 ") (def-var! ") (_a$7557 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$7558 " ") (_a$7559 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7560 " ") (_a$7561 b) (_a$7562 ")") (_a$7563 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$7564 ")")) (jolt-invoke _a$7551 _a$7552 _a$7553 _a$7554 _a$7555 _a$7556 _a$7557 _a$7558 _a$7559 _a$7560 _a$7561 _a$7562 _a$7563 _a$7564)))))) (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$7442 "+") (_o$7443 jolt-add) (_o$7444 "-") (_o$7445 jolt-sub) (_o$7446 "*") (_o$7447 jolt-mul) (_o$7448 "/") (_o$7449 jolt-div) (_o$7450 "<") (_o$7451 <) (_o$7452 ">") (_o$7453 >) (_o$7454 "<=") (_o$7455 <=) (_o$7456 ">=") (_o$7457 >=) (_o$7458 "=") (_o$7459 jolt=) (_o$7460 "inc") (_o$7461 jolt-inc) (_o$7462 "dec") (_o$7463 jolt-dec) (_o$7464 "mod") (_o$7465 modulo) (_o$7466 "rem") (_o$7467 remainder) (_o$7468 "quot") (_o$7469 quotient) (_o$7470 "bit-and") (_o$7471 (var-deref "clojure.core" "__bit-and")) (_o$7472 "bit-or") (_o$7473 (var-deref "clojure.core" "__bit-or")) (_o$7474 "bit-xor") (_o$7475 (var-deref "clojure.core" "__bit-xor"))) (jolt-hash-map _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 _o$7473 _o$7474 _o$7475)) (let* ((_o$7476 (keyword #f "private")) (_o$7477 #t)) (jolt-hash-map _o$7476 _o$7477)))) + (def-var-with-meta! "jolt.passes.fold" "foldable" (let* ((_o$7565 "+") (_o$7566 jolt-add) (_o$7567 "-") (_o$7568 jolt-sub) (_o$7569 "*") (_o$7570 jolt-mul) (_o$7571 "/") (_o$7572 jolt-div) (_o$7573 "<") (_o$7574 <) (_o$7575 ">") (_o$7576 >) (_o$7577 "<=") (_o$7578 <=) (_o$7579 ">=") (_o$7580 >=) (_o$7581 "=") (_o$7582 jolt=) (_o$7583 "inc") (_o$7584 jolt-inc) (_o$7585 "dec") (_o$7586 jolt-dec) (_o$7587 "mod") (_o$7588 modulo) (_o$7589 "rem") (_o$7590 remainder) (_o$7591 "quot") (_o$7592 quotient) (_o$7593 "bit-and") (_o$7594 (var-deref "clojure.core" "__bit-and")) (_o$7595 "bit-or") (_o$7596 (var-deref "clojure.core" "__bit-or")) (_o$7597 "bit-xor") (_o$7598 (var-deref "clojure.core" "__bit-xor"))) (jolt-hash-map _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 _o$7594 _o$7595 _o$7596 _o$7597 _o$7598)) (let* ((_o$7599 (keyword #f "private")) (_o$7600 #t)) (jolt-hash-map _o$7599 _o$7600)))) (guard (e (#t #f)) - (def-var! "jolt.passes.fold" "const?" (letrec ((const? (lambda (n) (let fnrec7478 ((n n)) (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))))) const?))) + (def-var! "jolt.passes.fold" "const?" (letrec ((const? (lambda (n) (let fnrec7601 ((n n)) (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))))) const?))) (guard (e (#t #f)) - (def-var! "jolt.passes.fold" "const-num?" (letrec ((const-num? (lambda (n) (let fnrec7479 ((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?))) + (def-var! "jolt.passes.fold" "const-num?" (letrec ((const-num? (lambda (n) (let fnrec7602 ((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?))) (guard (e (#t #f)) - (def-var! "jolt.passes.fold" "fold-fn" (letrec ((fold-fn (lambda (fnode) (let fnrec7480 ((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))) + (def-var! "jolt.passes.fold" "fold-fn" (letrec ((fold-fn (lambda (fnode) (let fnrec7603 ((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))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.fold" "const-fold" (letrec ((const-fold (lambda (node) (let fnrec7481 ((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$catch1547 (else (let* ((e _r$catch1547)) jolt-nil))) (let* ((_o$7483 (keyword #f "op")) (_o$7484 (keyword #f "const")) (_o$7485 (keyword #f "val")) (_o$7486 (jolt-apply ff (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (a) (let fnrec7482 ((a a)) (jolt-get a (keyword #f "val")))) args)))) (jolt-hash-map _o$7483 _o$7484 _o$7485 _o$7486))) 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$7487 node) (_a$7488 (keyword #f "test")) (_a$7489 t) (_a$7490 (keyword #f "then")) (_a$7491 (const-fold (jolt-get node (keyword #f "then")))) (_a$7492 (keyword #f "else")) (_a$7493 (const-fold (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$7487 _a$7488 _a$7489 _a$7490 _a$7491 _a$7492 _a$7493)))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") const-fold node) jolt-nil)))))))) const-fold) (let* ((_o$7494 (keyword #f "doc")) (_o$7495 "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$7494 _o$7495)))) + (def-var-with-meta! "jolt.passes.fold" "const-fold" (letrec ((const-fold (lambda (node) (let fnrec7604 ((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$catch1569 (else (let* ((e _r$catch1569)) jolt-nil))) (let* ((_o$7606 (keyword #f "op")) (_o$7607 (keyword #f "const")) (_o$7608 (keyword #f "val")) (_o$7609 (jolt-apply ff (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (a) (let fnrec7605 ((a a)) (jolt-get a (keyword #f "val")))) args)))) (jolt-hash-map _o$7606 _o$7607 _o$7608 _o$7609))) 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$7610 node) (_a$7611 (keyword #f "test")) (_a$7612 t) (_a$7613 (keyword #f "then")) (_a$7614 (const-fold (jolt-get node (keyword #f "then")))) (_a$7615 (keyword #f "else")) (_a$7616 (const-fold (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$7610 _a$7611 _a$7612 _a$7613 _a$7614 _a$7615 _a$7616)))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") const-fold node) jolt-nil)))))))) const-fold) (let* ((_o$7617 (keyword #f "doc")) (_o$7618 "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$7617 _o$7618)))) (guard (e (#t #f)) - (def-var! "jolt.passes.fold" "scalar-const?" (letrec ((scalar-const? (lambda (n) (let fnrec7496 ((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 fnrec7619 ((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 fnrec7497 ((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$7498 (keyword #f "doc")) (_o$7499 "True if fnode is a constant keyword used as a function head \x2014; the (:k m) form.")) (jolt-hash-map _o$7498 _o$7499)))) + (def-var-with-meta! "jolt.passes.fold" "kw-callee?" (letrec ((kw-callee? (lambda (fnode) (let fnrec7620 ((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$7621 (keyword #f "doc")) (_o$7622 "True if fnode is a constant keyword used as a function head \x2014; the (:k m) form.")) (jolt-hash-map _o$7621 _o$7622)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.fold" "get-callee?" (letrec ((get-callee? (lambda (fnode) (let fnrec7500 ((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$7501 (keyword #f "doc")) (_o$7502 "True if fnode is the clojure.core/get (or host get) callee \x2014; the (get m k) form.")) (jolt-hash-map _o$7501 _o$7502)))) + (def-var-with-meta! "jolt.passes.fold" "get-callee?" (letrec ((get-callee? (lambda (fnode) (let fnrec7623 ((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$7624 (keyword #f "doc")) (_o$7625 "True if fnode is the clojure.core/get (or host get) callee \x2014; the (get m k) form.")) (jolt-hash-map _o$7624 _o$7625)))) (guard (e (#t #f)) (def-var! "jolt.passes.numeric" "int-lit?" (letrec ((int-lit? (lambda (n) (let fnrec6041 ((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?))) (guard (e (#t #f)) @@ -371,7 +371,27 @@ (guard (e (#t #f)) (def-var-with-meta! "jolt.passes.inline" "elim-let-structs" (letrec ((elim-let-structs (lambda (node) (let fnrec6495 ((node node)) (let* ((binds (jolt-get node (keyword #f "bindings"))) (n (jolt-count binds)) (body (jolt-get node (keyword #f "body")))) (let* ((i 0)) (let loop6496 ((i i)) (if (< i n) (let* ((b (jolt-nth binds i)) (nm (jolt-nth b 0)) (init (jolt-nth b 1)) (ismap (let* ((and__25__auto (jolt= (keyword #f "map") (jolt-get init (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.inline" "const-key-map?") init))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.inline" "all-vals-pure?") init) and__25__auto)) and__25__auto))) (rs (if (jolt-not ismap) (jolt-invoke (var-deref "jolt.passes.inline" "ctor-shape") init) jolt-nil)) (isrec (let* ((and__25__auto rs)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.inline" "ctor-all-args-pure?") init) and__25__auto)))) (if (jolt-truthy? (let* ((and__25__auto (let* ((or__26__auto ismap)) (if (jolt-truthy? or__26__auto) or__26__auto isrec)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-invoke (var-deref "jolt.passes.inline" "any-binding-named?") (jolt-invoke (var-deref "clojure.core" "subvec") binds (jolt-inc i) n) nm)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (let* ((j (jolt-inc i))) (let loop6497 ((j j)) (if (< j n) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "local-escapes?") (jolt-nth (jolt-nth binds j) 1) nm)) #t (loop6497 (jolt-inc j))) #f)))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-invoke (var-deref "jolt.passes.inline" "local-escapes?") body nm)))) (if (jolt-truthy? and__25__auto) (let* ((or__26__auto ismap)) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((_a$6502 (var-deref "jolt.passes.inline" "lookups-all-fields?")) (_a$6503 (jolt-conj (let* ((_a$6499 (var-deref "clojure.core" "mapv")) (_a$6500 (lambda (bb) (let fnrec6498 ((bb bb)) (jolt-nth bb 1)))) (_a$6501 (jolt-invoke (var-deref "clojure.core" "subvec") binds (jolt-inc i) n))) (jolt-invoke _a$6499 _a$6500 _a$6501)) body)) (_a$6504 nm) (_a$6505 (jolt-get rs (keyword #f "fields")))) (jolt-invoke _a$6502 _a$6503 _a$6504 _a$6505)))) and__25__auto)) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((head (jolt-invoke (var-deref "clojure.core" "subvec") binds 0 i)) (tail (let* ((_a$6509 (var-deref "clojure.core" "mapv")) (_a$6510 (lambda (bb) (let fnrec6506 ((bb bb)) (let* ((_o$6507 (jolt-nth bb 0)) (_o$6508 (jolt-invoke (var-deref "jolt.passes.inline" "subst-lookup") (jolt-nth bb 1) nm init))) (jolt-vector _o$6507 _o$6508))))) (_a$6511 (jolt-invoke (var-deref "clojure.core" "subvec") binds (jolt-inc i) n))) (jolt-invoke _a$6509 _a$6510 _a$6511))) (newbinds (jolt-reduce jolt-conj head tail)) (newbody (jolt-invoke (var-deref "jolt.passes.inline" "subst-lookup") body nm init))) (begin (jolt-invoke (var-deref "jolt.passes.inline" "mark!")) (if (jolt= 0 (jolt-count newbinds)) newbody (jolt-assoc node (keyword #f "bindings") newbinds (keyword #f "body") newbody)))) (loop6496 (jolt-inc i)))) node)))))))) elim-let-structs) (let* ((_o$6512 (keyword #f "doc")) (_o$6513 "(b) Drop the first non-escaping let binding whose init is a foldable struct\n source \x2014; a pure const-key map literal or a pure record ctor \x2014; substituting its\n field reads into the remaining bindings and body. Fixpoint re-runs us for the\n rest, so one elimination per call keeps it simple. For a record every lookup\n of the binding must hit a declared field, else we keep the allocation.")) (jolt-hash-map _o$6512 _o$6513)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "scalar-replace" (letrec ((scalar-replace (lambda (node) (let fnrec6514 ((node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.passes.inline" "fold-kw-literal") (jolt-invoke (var-deref "jolt.ir" "map-ir-children") scalar-replace node)) (if (jolt= op (keyword #f "let")) (jolt-invoke (var-deref "jolt.passes.inline" "elim-let-structs") (jolt-invoke (var-deref "jolt.ir" "map-ir-children") scalar-replace node)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") scalar-replace node) jolt-nil)))))))) scalar-replace) (let* ((_o$6515 (keyword #f "doc")) (_o$6516 "Bottom-up: scalar-replace children, then apply (a) at invokes / (b) at lets.")) (jolt-hash-map _o$6515 _o$6516)))) + (def-var! "jolt.passes.inline" "local-node" (letrec ((local-node (lambda (nm) (let fnrec6514 ((nm nm)) (let* ((_o$6515 (keyword #f "op")) (_o$6516 (keyword #f "local")) (_o$6517 (keyword #f "name")) (_o$6518 nm)) (jolt-hash-map _o$6515 _o$6516 _o$6517 _o$6518)))))) local-node))) +(guard (e (#t #f)) + (def-var! "jolt.passes.inline" "core-call" (letrec ((core-call (lambda (nm cargs) (let fnrec6519 ((nm nm) (cargs cargs)) (let* ((_o$6526 (keyword #f "op")) (_o$6527 (keyword #f "invoke")) (_o$6528 (keyword #f "fn")) (_o$6529 (let* ((_o$6520 (keyword #f "op")) (_o$6521 (keyword #f "var")) (_o$6522 (keyword #f "ns")) (_o$6523 "clojure.core") (_o$6524 (keyword #f "name")) (_o$6525 nm)) (jolt-hash-map _o$6520 _o$6521 _o$6522 _o$6523 _o$6524 _o$6525))) (_o$6530 (keyword #f "args")) (_o$6531 (jolt-invoke (var-deref "clojure.core" "vec") cargs))) (jolt-hash-map _o$6526 _o$6527 _o$6528 _o$6529 _o$6530 _o$6531)))))) core-call))) +(guard (e (#t #f)) + (def-var-with-meta! "jolt.passes.inline" "reduce3-callee?" (letrec ((reduce3-callee? (lambda (node) (let fnrec6532 ((node node)) (let* ((f (jolt-get node (keyword #f "fn")))) (let* ((and__25__auto (jolt= (keyword #f "invoke") (jolt-get node (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= (keyword #f "var") (jolt-get f (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "clojure.core" (jolt-get f (keyword #f "ns"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "reduce" (jolt-get f (keyword #f "name"))))) (if (jolt-truthy? and__25__auto) (jolt= 3 (jolt-count (jolt-get node (keyword #f "args")))) and__25__auto)) and__25__auto)) and__25__auto)) and__25__auto))))))) reduce3-callee?) (let* ((_o$6533 (keyword #f "doc")) (_o$6534 "node is a (clojure.core/reduce f init coll) \x2014; the 3-arg form with an explicit\n initial value (the 2-arg form seeds from the collection, a different shape).")) (jolt-hash-map _o$6533 _o$6534)))) +(guard (e (#t #f)) + (def-var! "jolt.passes.inline" "same-shape-ctor?" (letrec ((same-shape-ctor? (lambda (node rs) (let fnrec6535 ((node node) (rs rs)) (let* ((cs (jolt-invoke (var-deref "jolt.passes.inline" "ctor-shape") node))) (let* ((and__25__auto cs)) (if (jolt-truthy? and__25__auto) (let* ((_a$6536 (jolt-get cs (keyword #f "type"))) (_a$6537 (jolt-get rs (keyword #f "type")))) (jolt= _a$6536 _a$6537)) and__25__auto))))))) same-shape-ctor?))) +(guard (e (#t #f)) + (def-var-with-meta! "jolt.passes.inline" "acc-ok?" (letrec ((acc-ok? (lambda (node nm rs tail?) (let fnrec6538 ((node node) (nm nm) (rs rs) (tail? tail?)) (let* ((op (jolt-get node (keyword #f "op"))) (k (jolt-invoke (var-deref "jolt.passes.inline" "lookup-key") node nm))) (if (jolt-truthy? k) (let* ((args (jolt-get node (keyword #f "args")))) (if (> (jolt-count args) 1) (let* ((_a$6540 (var-deref "clojure.core" "every?")) (_a$6541 (lambda (a) (let fnrec6539 ((a a)) (acc-ok? a nm rs #f)))) (_a$6542 (jolt-invoke (var-deref "clojure.core" "subvec") args 1 (jolt-count args)))) (jolt-invoke _a$6540 _a$6541 _a$6542)) #t)) (if (jolt= op (keyword #f "local")) (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "not=") nm (jolt-get node (keyword #f "name"))))) (if (jolt-truthy? or__26__auto) or__26__auto tail?)) (if (jolt= op (keyword #f "const")) #t (if (jolt= op (keyword #f "var")) #t (if (jolt= op (keyword #f "host")) #t (if (jolt= op (keyword #f "the-var")) #t (if (jolt= op (keyword #f "quote")) #t (if (jolt= op (keyword #f "if")) (let* ((and__25__auto (acc-ok? (jolt-get node (keyword #f "test")) nm rs #f))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (acc-ok? (jolt-get node (keyword #f "then")) nm rs tail?))) (if (jolt-truthy? and__25__auto) (acc-ok? (jolt-get node (keyword #f "else")) nm rs tail?) and__25__auto)) and__25__auto)) (if (jolt= op (keyword #f "do")) (let* ((and__25__auto (let* ((_a$6544 (var-deref "clojure.core" "every?")) (_a$6545 (lambda (s) (let fnrec6543 ((s s)) (acc-ok? s nm rs #f)))) (_a$6546 (jolt-get node (keyword #f "statements")))) (jolt-invoke _a$6544 _a$6545 _a$6546)))) (if (jolt-truthy? and__25__auto) (acc-ok? (jolt-get node (keyword #f "ret")) nm rs tail?) and__25__auto)) (if (jolt= op (keyword #f "let")) (let* ((and__25__auto (let* ((_a$6548 (var-deref "clojure.core" "every?")) (_a$6549 (lambda (b) (let fnrec6547 ((b b)) (acc-ok? (jolt-nth b 1) nm rs #f)))) (_a$6550 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$6548 _a$6549 _a$6550)))) (if (jolt-truthy? and__25__auto) (let* ((or__26__auto (jolt-invoke (var-deref "jolt.passes.inline" "any-binding-named?") (jolt-get node (keyword #f "bindings")) nm))) (if (jolt-truthy? or__26__auto) or__26__auto (acc-ok? (jolt-get node (keyword #f "body")) nm rs tail?))) and__25__auto)) (if (jolt= op (keyword #f "invoke")) (let* ((and__25__auto (acc-ok? (jolt-get node (keyword #f "fn")) nm rs #f))) (if (jolt-truthy? and__25__auto) (let* ((_a$6552 (var-deref "clojure.core" "every?")) (_a$6553 (lambda (a) (let fnrec6551 ((a a)) (acc-ok? a nm rs #f)))) (_a$6554 (jolt-get node (keyword #f "args")))) (jolt-invoke _a$6552 _a$6553 _a$6554)) and__25__auto)) (if (jolt= op (keyword #f "throw")) (acc-ok? (jolt-get node (keyword #f "expr")) nm rs #f) (if (jolt= op (keyword #f "vector")) (let* ((_a$6556 (var-deref "clojure.core" "every?")) (_a$6557 (lambda (a) (let fnrec6555 ((a a)) (acc-ok? a nm rs #f)))) (_a$6558 (jolt-get node (keyword #f "items")))) (jolt-invoke _a$6556 _a$6557 _a$6558)) (if (jolt= op (keyword #f "set")) (let* ((_a$6560 (var-deref "clojure.core" "every?")) (_a$6561 (lambda (a) (let fnrec6559 ((a a)) (acc-ok? a nm rs #f)))) (_a$6562 (jolt-get node (keyword #f "items")))) (jolt-invoke _a$6560 _a$6561 _a$6562)) (if (jolt= op (keyword #f "map")) (let* ((_a$6564 (var-deref "clojure.core" "every?")) (_a$6565 (lambda (p) (let fnrec6563 ((p p)) (let* ((and__25__auto (acc-ok? (jolt-nth p 0) nm rs #f))) (if (jolt-truthy? and__25__auto) (acc-ok? (jolt-nth p 1) nm rs #f) and__25__auto))))) (_a$6566 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$6564 _a$6565 _a$6566)) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))))))))))))))))))) acc-ok?) (let* ((_o$6567 (keyword #f "doc")) (_o$6568 "Is acc (local nm, record shape rs) safe to scalarize across body? It may appear\n ONLY as a constant-field-read subject, or \x2014; in tail position \x2014; as the bare\n carried-forward value. tail? marks whether node is the reduce-fn's return value.\n A binding/control form that could capture or rebind acc bails (false).")) (jolt-hash-map _o$6567 _o$6568)))) +(guard (e (#t #f)) + (def-var-with-meta! "jolt.passes.inline" "tails-valid?" (letrec ((tails-valid? (lambda (node nm rs) (let fnrec6569 ((node node) (nm nm) (rs rs)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((and__25__auto (tails-valid? (jolt-get node (keyword #f "then")) nm rs))) (if (jolt-truthy? and__25__auto) (tails-valid? (jolt-get node (keyword #f "else")) nm rs) and__25__auto)) (if (jolt= op (keyword #f "do")) (tails-valid? (jolt-get node (keyword #f "ret")) nm rs) (if (jolt= op (keyword #f "let")) (tails-valid? (jolt-get node (keyword #f "body")) nm rs) (if (let* ((and__25__auto (jolt= op (keyword #f "local")))) (if (jolt-truthy? and__25__auto) (jolt= nm (jolt-get node (keyword #f "name"))) and__25__auto)) #t (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.passes.inline" "same-shape-ctor?") node rs) jolt-nil)))))))))) tails-valid?) (let* ((_o$6570 (keyword #f "doc")) (_o$6571 "Every tail position of body returns a same-shape ctor or the bare acc \x2014; the\n values the recur can carry as exploded scalars. (A `reduced` tail, or any other\n shape, isn't one of these, so it keeps the ordinary reduce.)")) (jolt-hash-map _o$6570 _o$6571)))) +(guard (e (#t #f)) + (def-var-with-meta! "jolt.passes.inline" "subst-acc-fields" (letrec ((subst-acc-fields (lambda (node nm fields acc-locals) (let fnrec6572 ((node node) (nm nm) (fields fields) (acc-locals acc-locals)) (let* ((k (jolt-invoke (var-deref "jolt.passes.inline" "lookup-key") node nm))) (if (jolt-truthy? k) (jolt-nth acc-locals (jolt-invoke (var-deref "jolt.passes.inline" "field-index") fields k)) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec6573 ((c c)) (subst-acc-fields c nm fields acc-locals))) node))))))) subst-acc-fields) (let* ((_o$6574 (keyword #f "doc")) (_o$6575 "Replace every (:k acc)/(get acc :k) in node with the scalar loop var for field k.\n acc-ok? guarantees acc appears only as such reads (or the bare tail), so a uniform\n recursion is safe.")) (jolt-hash-map _o$6574 _o$6575)))) +(guard (e (#t #f)) + (def-var-with-meta! "jolt.passes.inline" "tail->recur" (letrec ((tail->recur (lambda (node nm acc-locals snm) (let fnrec6576 ((node node) (nm nm) (acc-locals acc-locals) (snm snm)) (let* ((op (jolt-get node (keyword #f "op"))) (step (lambda (t) (let fnrec6577 ((t t)) (tail->recur t nm acc-locals snm)))) (recur-with (lambda (comps) (let fnrec6578 ((comps comps)) (let* ((_o$6579 (keyword #f "op")) (_o$6580 (keyword #f "recur")) (_o$6581 (keyword #f "args")) (_o$6582 (jolt-reduce jolt-conj (jolt-vector (jolt-invoke (var-deref "jolt.passes.inline" "core-call") "next" (jolt-vector (jolt-invoke (var-deref "jolt.passes.inline" "local-node") snm)))) comps))) (jolt-hash-map _o$6579 _o$6580 _o$6581 _o$6582)))))) (if (jolt= op (keyword #f "if")) (let* ((_a$6583 node) (_a$6584 (keyword #f "then")) (_a$6585 (jolt-invoke step (jolt-get node (keyword #f "then")))) (_a$6586 (keyword #f "else")) (_a$6587 (jolt-invoke step (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$6583 _a$6584 _a$6585 _a$6586 _a$6587)) (if (jolt= op (keyword #f "do")) (jolt-assoc node (keyword #f "ret") (jolt-invoke step (jolt-get node (keyword #f "ret")))) (if (jolt= op (keyword #f "let")) (jolt-assoc node (keyword #f "body") (jolt-invoke step (jolt-get node (keyword #f "body")))) (if (let* ((and__25__auto (jolt= op (keyword #f "local")))) (if (jolt-truthy? and__25__auto) (jolt= nm (jolt-get node (keyword #f "name"))) and__25__auto)) (jolt-invoke recur-with acc-locals) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke recur-with (jolt-get node (keyword #f "args"))) jolt-nil)))))))))) tail->recur) (let* ((_o$6588 (keyword #f "doc")) (_o$6589 "Convert each tail of body (already field-substituted) into a recur that advances\n the seq and carries the next accumulator components: a same-shape ctor explodes\n into its positional args, the bare acc carries the current components forward.")) (jolt-hash-map _o$6588 _o$6589)))) +(guard (e (#t #f)) + (def-var-with-meta! "jolt.passes.inline" "lower-reduce" (letrec ((lower-reduce (lambda (node) (let fnrec6590 ((node node)) (let* ((args (jolt-get node (keyword #f "args"))) (closure (jolt-nth args 0)) (init (jolt-nth args 1)) (coll (jolt-nth args 2)) (ar (jolt-first (jolt-get closure (keyword #f "arities")))) (params (jolt-get ar (keyword #f "params"))) (nm (jolt-nth params 0)) (xnm (jolt-nth params 1)) (body (jolt-get ar (keyword #f "body"))) (rs (jolt-invoke (var-deref "jolt.passes.inline" "ctor-shape") init)) (fields (jolt-get rs (keyword #f "fields"))) (snm (jolt-invoke (var-deref "jolt.passes.inline" "fresh") "rseq")) (accnms (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (_) (let fnrec6591 ((_ _)) (jolt-invoke (var-deref "jolt.passes.inline" "fresh") "racc"))) fields)) (acc-locals (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.passes.inline" "local-node") accnms)) (body_PRIME_ (jolt-invoke (var-deref "jolt.passes.inline" "tail->recur") (jolt-invoke (var-deref "jolt.passes.inline" "subst-acc-fields") body nm fields acc-locals) nm acc-locals snm))) (let* ((_o$6626 (keyword #f "op")) (_o$6627 (keyword #f "loop")) (_o$6628 (keyword #f "bindings")) (_o$6629 (let* ((_a$6601 jolt-conj) (_a$6602 (jolt-vector (let* ((_o$6592 snm) (_o$6593 (jolt-invoke (var-deref "jolt.passes.inline" "core-call") "seq" (jolt-vector coll)))) (jolt-vector _o$6592 _o$6593)))) (_a$6603 (let* ((_a$6597 (var-deref "clojure.core" "mapv")) (_a$6598 (lambda (an ia) (let fnrec6594 ((an an) (ia ia)) (let* ((_o$6595 an) (_o$6596 ia)) (jolt-vector _o$6595 _o$6596))))) (_a$6599 accnms) (_a$6600 (jolt-get init (keyword #f "args")))) (jolt-invoke _a$6597 _a$6598 _a$6599 _a$6600)))) (jolt-reduce _a$6601 _a$6602 _a$6603))) (_o$6630 (keyword #f "body")) (_o$6631 (let* ((_o$6618 (keyword #f "op")) (_o$6619 (keyword #f "if")) (_o$6620 (keyword #f "test")) (_o$6621 (jolt-invoke (var-deref "jolt.passes.inline" "core-call") "nil?" (jolt-vector (jolt-invoke (var-deref "jolt.passes.inline" "local-node") snm)))) (_o$6622 (keyword #f "then")) (_o$6623 (let* ((_o$6604 (keyword #f "op")) (_o$6605 (keyword #f "invoke")) (_o$6606 (keyword #f "fn")) (_o$6607 (jolt-get init (keyword #f "fn"))) (_o$6608 (keyword #f "args")) (_o$6609 acc-locals)) (jolt-hash-map _o$6604 _o$6605 _o$6606 _o$6607 _o$6608 _o$6609))) (_o$6624 (keyword #f "else")) (_o$6625 (let* ((_o$6612 (keyword #f "op")) (_o$6613 (keyword #f "let")) (_o$6614 (keyword #f "bindings")) (_o$6615 (jolt-vector (let* ((_o$6610 xnm) (_o$6611 (jolt-invoke (var-deref "jolt.passes.inline" "core-call") "first" (jolt-vector (jolt-invoke (var-deref "jolt.passes.inline" "local-node") snm))))) (jolt-vector _o$6610 _o$6611)))) (_o$6616 (keyword #f "body")) (_o$6617 body_PRIME_)) (jolt-hash-map _o$6612 _o$6613 _o$6614 _o$6615 _o$6616 _o$6617)))) (jolt-hash-map _o$6618 _o$6619 _o$6620 _o$6621 _o$6622 _o$6623 _o$6624 _o$6625)))) (jolt-hash-map _o$6626 _o$6627 _o$6628 _o$6629 _o$6630 _o$6631))))))) lower-reduce) (let* ((_o$6632 (keyword #f "doc")) (_o$6633 "Rewrite a lowerable (reduce (fn [acc x] body) (->Rec inits) coll) into a seq loop\n with acc's fields carried as scalar vars. Caller has validated the shape.")) (jolt-hash-map _o$6632 _o$6633)))) +(guard (e (#t #f)) + (def-var-with-meta! "jolt.passes.inline" "try-lower-reduce" (letrec ((try-lower-reduce (lambda (node) (let fnrec6634 ((node node)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "reduce3-callee?") node)) (let* ((closure (jolt-nth (jolt-get node (keyword #f "args")) 0)) (init (jolt-nth (jolt-get node (keyword #f "args")) 1)) (ars (jolt-get closure (keyword #f "arities")))) (if (jolt-truthy? (let* ((and__25__auto (jolt= (keyword #f "fn") (jolt-get closure (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= 1 (jolt-count ars)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= 2 (jolt-count (jolt-get (jolt-first ars) (keyword #f "params")))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-get (jolt-first ars) (keyword #f "rest"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.inline" "ctor-shape") init) and__25__auto)) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((ar (jolt-first ars)) (nm (jolt-nth (jolt-get ar (keyword #f "params")) 0)) (body (jolt-get ar (keyword #f "body"))) (rs (jolt-invoke (var-deref "jolt.passes.inline" "ctor-shape") init))) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.inline" "acc-ok?") body nm rs #t))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.inline" "tails-valid?") body nm rs) and__25__auto))) (jolt-invoke (var-deref "jolt.passes.inline" "lower-reduce") node) jolt-nil)) jolt-nil)) jolt-nil))))) try-lower-reduce) (let* ((_o$6635 (keyword #f "doc")) (_o$6636 "Lower a (reduce closure (->Rec inits) coll) when the closure is a single-arity\n 2-param literal fn and acc is a non-escaping record; else nil.")) (jolt-hash-map _o$6635 _o$6636)))) +(guard (e (#t #f)) + (def-var-with-meta! "jolt.passes.inline" "scalar-replace" (letrec ((scalar-replace (lambda (node) (let fnrec6637 ((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") scalar-replace node))) (let* ((temp__16__auto (jolt-invoke (var-deref "jolt.passes.inline" "try-lower-reduce") n))) (if (jolt-truthy? temp__16__auto) (let* ((low temp__16__auto)) (begin (jolt-invoke (var-deref "jolt.passes.inline" "mark!")) low)) (jolt-invoke (var-deref "jolt.passes.inline" "fold-kw-literal") n)))) (if (jolt= op (keyword #f "let")) (jolt-invoke (var-deref "jolt.passes.inline" "elim-let-structs") (jolt-invoke (var-deref "jolt.ir" "map-ir-children") scalar-replace node)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") scalar-replace node) jolt-nil)))))))) scalar-replace) (let* ((_o$6638 (keyword #f "doc")) (_o$6639 "Bottom-up: scalar-replace children, then apply (a) at invokes / (b) at lets.")) (jolt-hash-map _o$6638 _o$6639)))) (guard (e (#t #f)) (def-var! "jolt.passes.types.lattice" "velem" (letrec ((velem (lambda (t) (let fnrec5835 ((t t)) (jolt-get t (keyword #f "vec")))))) velem))) (guard (e (#t #f)) diff --git a/jolt-core/jolt/passes/inline.clj b/jolt-core/jolt/passes/inline.clj index 08f5bc8..53ab3f4 100644 --- a/jolt-core/jolt/passes/inline.clj +++ b/jolt-core/jolt/passes/inline.clj @@ -546,13 +546,161 @@ (recur (inc i)))) node)))) +;; --- reduce-accumulator scalar replacement ---------------------------------- +;; (reduce (fn [acc x] body) (->Rec inits..) coll) where acc is a non-escaping +;; record — read only via its fields, returned each step as a same-shape ctor or +;; carried forward unchanged — allocates one record PER ELEMENT. Lower it to a seq +;; loop that carries acc's fields as scalar loop vars and rebuilds the record once +;; at exit, so the per-step allocation disappears. This is the ray tracer's hit-all +;; (a HitAcc per sphere test). Closed-world (--opt) only, like the rest of this pass. + +(defn- local-node [nm] {:op :local :name nm}) +(defn- core-call [nm cargs] {:op :invoke :fn {:op :var :ns "clojure.core" :name nm} :args (vec cargs)}) + +(defn- reduce3-callee? + "node is a (clojure.core/reduce f init coll) — the 3-arg form with an explicit + initial value (the 2-arg form seeds from the collection, a different shape)." + [node] + (let [f (get node :fn)] + (and (= :invoke (get node :op)) + (= :var (get f :op)) (= "clojure.core" (get f :ns)) (= "reduce" (get f :name)) + (= 3 (count (get node :args)))))) + +(defn- same-shape-ctor? [node rs] + (let [cs (ctor-shape node)] (and cs (= (get cs :type) (get rs :type))))) + +(defn- acc-ok? + "Is acc (local nm, record shape rs) safe to scalarize across body? It may appear + ONLY as a constant-field-read subject, or — in tail position — as the bare + carried-forward value. tail? marks whether node is the reduce-fn's return value. + A binding/control form that could capture or rebind acc bails (false)." + [node nm rs tail?] + (let [op (get node :op) + k (lookup-key node nm)] + (cond + ;; a field read of acc: nm is consumed as the subject; a get-default (extra + ;; arg) is non-tail and must not leak acc either. + k (let [args (get node :args)] + (if (> (count args) 1) + (every? (fn [a] (acc-ok? a nm rs false)) (subvec args 1 (count args))) + true)) + (= op :local) (or (not= nm (get node :name)) tail?) ;; bare acc only ok in tail + (= op :const) true (= op :var) true (= op :host) true + (= op :the-var) true (= op :quote) true + (= op :if) (and (acc-ok? (get node :test) nm rs false) + (acc-ok? (get node :then) nm rs tail?) + (acc-ok? (get node :else) nm rs tail?)) + (= op :do) (and (every? (fn [s] (acc-ok? s nm rs false)) (get node :statements)) + (acc-ok? (get node :ret) nm rs tail?)) + (= op :let) (and (every? (fn [b] (acc-ok? (nth b 1) nm rs false)) (get node :bindings)) + (or (any-binding-named? (get node :bindings) nm) ;; nm shadowed below + (acc-ok? (get node :body) nm rs tail?))) + (= op :invoke) (and (acc-ok? (get node :fn) nm rs false) + (every? (fn [a] (acc-ok? a nm rs false)) (get node :args))) + (= op :throw) (acc-ok? (get node :expr) nm rs false) + (= op :vector) (every? (fn [a] (acc-ok? a nm rs false)) (get node :items)) + (= op :set) (every? (fn [a] (acc-ok? a nm rs false)) (get node :items)) + (= op :map) (every? (fn [p] (and (acc-ok? (nth p 0) nm rs false) + (acc-ok? (nth p 1) nm rs false))) (get node :pairs)) + ;; :fn/:loop/:recur/:try/:def — acc could be captured, or a nested recur would + ;; collide with the loop we synthesize; conservatively bail. + :else false))) + +(defn- tails-valid? + "Every tail position of body returns a same-shape ctor or the bare acc — the + values the recur can carry as exploded scalars. (A `reduced` tail, or any other + shape, isn't one of these, so it keeps the ordinary reduce.)" + [node nm rs] + (let [op (get node :op)] + (cond + (= op :if) (and (tails-valid? (get node :then) nm rs) (tails-valid? (get node :else) nm rs)) + (= op :do) (tails-valid? (get node :ret) nm rs) + (= op :let) (tails-valid? (get node :body) nm rs) + (and (= op :local) (= nm (get node :name))) true + :else (same-shape-ctor? node rs)))) + +(defn- subst-acc-fields + "Replace every (:k acc)/(get acc :k) in node with the scalar loop var for field k. + acc-ok? guarantees acc appears only as such reads (or the bare tail), so a uniform + recursion is safe." + [node nm fields acc-locals] + (let [k (lookup-key node nm)] + (if k + (nth acc-locals (field-index fields k)) + (map-ir-children (fn [c] (subst-acc-fields c nm fields acc-locals)) node)))) + +(defn- tail->recur + "Convert each tail of body (already field-substituted) into a recur that advances + the seq and carries the next accumulator components: a same-shape ctor explodes + into its positional args, the bare acc carries the current components forward." + [node nm acc-locals snm] + (let [op (get node :op) + step (fn [t] (tail->recur t nm acc-locals snm)) + recur-with (fn [comps] {:op :recur :args (reduce conj [(core-call "next" [(local-node snm)])] comps)})] + (cond + (= op :if) (assoc node :then (step (get node :then)) :else (step (get node :else))) + (= op :do) (assoc node :ret (step (get node :ret))) + (= op :let) (assoc node :body (step (get node :body))) + (and (= op :local) (= nm (get node :name))) (recur-with acc-locals) + :else (recur-with (get node :args))))) ;; a same-shape ctor: its args are the new components + +(defn- lower-reduce + "Rewrite a lowerable (reduce (fn [acc x] body) (->Rec inits) coll) into a seq loop + with acc's fields carried as scalar vars. Caller has validated the shape." + [node] + (let [args (get node :args) + closure (nth args 0) init (nth args 1) coll (nth args 2) + ar (first (get closure :arities)) + params (get ar :params) + nm (nth params 0) xnm (nth params 1) + body (get ar :body) + rs (ctor-shape init) + fields (get rs :fields) + snm (fresh "rseq") + accnms (mapv (fn [_] (fresh "racc")) fields) + acc-locals (mapv local-node accnms) + body' (tail->recur (subst-acc-fields body nm fields acc-locals) nm acc-locals snm)] + {:op :loop + :bindings (reduce conj [[snm (core-call "seq" [coll])]] + (mapv (fn [an ia] [an ia]) accnms (get init :args))) + :body {:op :if + :test (core-call "nil?" [(local-node snm)]) + ;; exhausted: rebuild the record once from the final components + :then {:op :invoke :fn (get init :fn) :args acc-locals} + :else {:op :let :bindings [[xnm (core-call "first" [(local-node snm)])]] + :body body'}}})) + +(defn- try-lower-reduce + "Lower a (reduce closure (->Rec inits) coll) when the closure is a single-arity + 2-param literal fn and acc is a non-escaping record; else nil." + [node] + (when (reduce3-callee? node) + (let [closure (nth (get node :args) 0) + init (nth (get node :args) 1) + ars (get closure :arities)] + (when (and (= :fn (get closure :op)) (= 1 (count ars)) + (= 2 (count (get (first ars) :params))) + (not (get (first ars) :rest)) + (ctor-shape init)) + (let [ar (first ars) + nm (nth (get ar :params) 0) + body (get ar :body) + rs (ctor-shape init)] + (when (and (acc-ok? body nm rs true) (tails-valid? body nm rs)) + (lower-reduce node))))))) + (defn scalar-replace "Bottom-up: scalar-replace children, then apply (a) at invokes / (b) at lets." [node] (let [op (get node :op)] (cond - ;; (a) fold (:k ) at invokes, after scalar-replacing children - (= op :invoke) (fold-kw-literal (map-ir-children scalar-replace node)) + ;; (a) at invokes: lower a reduce-over-record-accumulator to a loop, else fold + ;; (:k ) — both after scalar-replacing children. + (= op :invoke) + (let [n (map-ir-children scalar-replace node)] + (if-let [low (try-lower-reduce n)] + (do (mark!) low) + (fold-kw-literal n))) ;; (b) drop a non-escaping foldable-struct let binding, after children (= op :let) (elim-let-structs (map-ir-children scalar-replace node)) :else (map-ir-children scalar-replace node))))