You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
86 lines
3.7 KiB
Racket
86 lines
3.7 KiB
Racket
#lang racket/base
|
|
(require racket/list)
|
|
(require (planet mb/pollen/tools) (planet mb/pollen/main-helper))
|
|
(provide (except-out (all-from-out racket/base) #%module-begin)
|
|
(rename-out [module-begin #%module-begin]))
|
|
|
|
(define-syntax-rule (module-begin expr ...)
|
|
(#%module-begin
|
|
|
|
; this is here only so that dynamic-rerequire of a pollen module
|
|
; transitively reloads the extras also.
|
|
; if this isn't here, then dynamic-rerequire can't see them
|
|
; and thus they are not tracked for changes.
|
|
(require-extras)
|
|
|
|
; We want our module language to support require & provide
|
|
; which are only supported at the module level, so ...
|
|
; create a submodule to contain the input
|
|
; and export as needed
|
|
|
|
; doclang2_raw is a clone of scribble/doclang2 with decode disabled
|
|
; helpful because it collects & exports content via 'doc
|
|
(module pollen-inner (planet mb/pollen/lang/doclang2_raw)
|
|
; use same requires as top of main.rkt
|
|
; (can't import them from surrounding module due to submodule rules)
|
|
(require (planet mb/pollen/tools) (planet mb/pollen/main-helper))
|
|
(require-extras #:provide #t) ; brings in the project require files
|
|
|
|
; #%top binding catches ids that aren't defined
|
|
; here, convert them to basic xexpr
|
|
; #%top is a syntax transformer that returns a function
|
|
; λ x captures all the args (vs. λ(x), which only catches one)
|
|
; and id is not spliced because it's syntax, not a true variable
|
|
(define-syntax-rule (#%top . id)
|
|
(λ x `(id ,@x)))
|
|
|
|
expr ... ; body of module
|
|
|
|
;; set up a hook for identifier 'here'
|
|
;; (but under a different name to avoid macrofication)
|
|
(define inner-here here)
|
|
(provide (all-defined-out)))
|
|
|
|
(require 'pollen-inner) ; provides doc & #%top, among other things
|
|
|
|
;; prepare the elements, and append inner-here as meta.
|
|
(define all-elements (append
|
|
(cond
|
|
;; doc is probably a list, but might be a single string
|
|
[(string? doc) (list doc)]
|
|
[(tagged-xexpr? doc) (list doc)] ; if it's a single nx, just leave it
|
|
[(list? doc) doc]) ; if it's nx content, splice it in
|
|
(list `(meta "here" ,inner-here)))) ; append inner-here as meta
|
|
|
|
;; split out the metas now (in raw form)
|
|
(define-values (main-raw metas-raw)
|
|
(extract-tag-from-xexpr 'meta (make-tagged-xexpr 'irrelevant-tag empty all-elements)))
|
|
|
|
;; Policy: here in the core lang, do as little to main as possible.
|
|
;; The point is just to set it up for further processing.
|
|
;; One of the annoyances of Scribble is its insistence on decoding.
|
|
;; Better just to pass through the minimally processed data.
|
|
;; Root is treated as a function.
|
|
;; If it's not defined elsewhere, it just hits #%top and becomes a tagged-xexpr.
|
|
(define main (apply root (tagged-xexpr-elements main-raw)))
|
|
|
|
(define metas (make-meta-hash metas-raw))
|
|
|
|
(provide main metas
|
|
(except-out (all-from-out 'pollen-inner) inner-here) ; everything from user
|
|
(rename-out (inner-here here))) ; change identifier back (now safe from macrofication)
|
|
|
|
(module+ main
|
|
(displayln ";-------------------------")
|
|
(displayln "; pollen decoded 'main")
|
|
(displayln ";-------------------------")
|
|
main
|
|
(displayln "")
|
|
(displayln (format "(tagged-xexpr? main) ~a" (tagged-xexpr? main)))
|
|
(displayln "")
|
|
(displayln ";-------------------------")
|
|
(displayln "; pollen 'metas")
|
|
(displayln ";-------------------------")
|
|
metas
|
|
)))
|