std.lang.base.emit-preprocess — xyz.zcaudate/std.lang 4.1.0

*macro-form* clj

*macro-grammar* clj

*macro-opts* clj

*macro-skip-deps* clj

*macro-splice* clj

find-natives clj

(find-natives entry mopts)

get-fragment clj

(get-fragment sym modules mopts)

gets the fragment given a symbol and modules

macro-form clj

(macro-form)

gets the current macro form

macro-grammar clj

(macro-grammar)

gets the current grammar

macro-opts clj

(macro-opts)

gets current macro-opts

process-inline-assignment clj

(process-inline-assignment form modules mopts & [unwrapped])

prepares the form for inline assignment

process-namespaced-resolve clj

(process-namespaced-resolve sym modules {:keys [module entry] :as mopts})

resolves symbol in current namespace

process-namespaced-symbol clj

(process-namespaced-symbol sym
                           modules
                           {:keys [module entry] :as mopts}
                           deps
                           deps-fragment
                           walk-fn)

process namespaced symbols

process-standard-symbol clj

(process-standard-symbol sym mopts deps-native)

to-input clj

(to-input raw)

converts a form to input (extracting deref forms)

to-input-form clj

(to-input-form [tag input & more :as x])

processes a form

(def hello 1)

(to-input-form '(@! (+ 1 2 3))) => '(!:template (+ 1 2 3))

(to-input-form '(-/Class$$new)) => (any '(static-invoke -/Class "new") nil)

(to-input-form '(Class$$new 1 2 3)) => (any '(static-invoke Class "new" 1 2 3) nil)

(to-input-form '@#'hello) => '(!:deref (var std.lang.base.emit-preprocess-test/hello))

(to-input-form '@(+ 1 2 3)) => '(!:eval (+ 1 2 3))

(to-input-form '(@.lua (do 1 2 3))) => '(!:lang {:lang :lua} (do 1 2 3))

to-resolve clj

(to-resolve input grammar modules mopts)

resolves only the code symbols (no macroexpansion)

to-staging clj

(to-staging input grammar modules mopts)

converts the stage

to-staging-form clj

(to-staging-form form grammar modules mopts deps-fragment walk-fn)

different staging forms

with:macro-opts clj macro

(with:macro-opts [mopts] & body)

bind macro opts