166 lines
6.4 KiB
Scheme
166 lines
6.4 KiB
Scheme
|
|
(module deriv-c mzscheme
|
|
(provide (all-defined))
|
|
|
|
;; A Derivation is either
|
|
;; - a PRule
|
|
;; - (make-mrule syntax syntax Transformation Derivation)
|
|
;; - (make-lift-deriv syntax syntax Derivation syntax Derivation)
|
|
;; - (make-lift/let-deriv syntax syntax Derivation syntax Derivation)
|
|
(define-struct deriv (e1 e2) #f)
|
|
(define-struct (mrule deriv) (transformation next) #f)
|
|
(define-struct (lift-deriv deriv) (first lift-stx second) #f)
|
|
(define-struct (lift/let-deriv deriv) (first lift-stx second) #f)
|
|
|
|
;; A Transformation is
|
|
;; (make-transformation syntax syntax (listof identifier) syntax syntax (listof LocalAction))
|
|
;; - resolves is the list of identifiers resolved by the macro keyword
|
|
;; - me1 is the marked version of the input syntax
|
|
;; - me2 is the marked version of the output syntax
|
|
(define-struct transformation (e1 e2 resolves me1 me2 locals seq) #f)
|
|
|
|
;; A LocalAction is one of
|
|
;; - (make-local-expansion Syntax Syntax Syntax Syntax boolean Derivation)
|
|
;; - (make-local-expansion/expr Syntax Syntax Syntax Syntax boolean Derivation)
|
|
;; - (make-local-lift Syntax Identifier)
|
|
(define-struct local-expansion (e1 e2 me1 me2 for-stx? deriv) #f)
|
|
(define-struct local-expansion/expr (e1 e2 me1 me2 for-stx? opaque deriv) #f)
|
|
(define-struct local-lift (expr id) #f)
|
|
(define-struct local-lift-end (decl) #f)
|
|
(define-struct local-bind (deriv) #f)
|
|
|
|
;; A PRule is one of ...
|
|
(define-struct (prule deriv) (resolves) #f)
|
|
|
|
;; Lexical or Mapped Variable
|
|
(define-struct (p:variable prule) () #f)
|
|
|
|
;; Definitions: one subterm each
|
|
(define-struct (p:define-syntaxes prule) (rhs) #f)
|
|
(define-struct (p:define-values prule) (rhs) #f)
|
|
|
|
;; Simple expressions
|
|
(define-struct (p:expression prule) (inner) #f)
|
|
(define-struct (p:if prule) (full? test then else) #f)
|
|
(define-struct (p:wcm prule) (key mark body) #f)
|
|
(define-struct (p:set! prule) (id-resolves rhs) #f)
|
|
(define-struct (p:set!-macro prule) (deriv) #f)
|
|
|
|
;; Sequence-containing expressions
|
|
(define-struct (p:begin prule) (lderiv) #f)
|
|
(define-struct (p:begin0 prule) (first lderiv) #f)
|
|
(define-struct (p:#%app prule) (tagged-stx lderiv) #f)
|
|
|
|
;; Binding expressions
|
|
(define-struct (p:lambda prule) (renames body) #f)
|
|
(define-struct (p:case-lambda prule) (renames+bodies) #f)
|
|
(define-struct (p:let-values prule) (renames rhss body) #f)
|
|
(define-struct (p:letrec-values prule) (renames rhss body) #f)
|
|
(define-struct (p:letrec-syntaxes+values prule) (srenames srhss vrenames vrhss body) #f)
|
|
|
|
;; Atomic primitives: no subterms
|
|
(define-struct (p::STOP prule) () #f)
|
|
(define-struct (p:#%datum p::STOP) (tagged-stx) #f)
|
|
(define-struct (p:#%top p::STOP) (tagged-stx) #f)
|
|
(define-struct (p:quote p::STOP) () #f)
|
|
(define-struct (p:quote-syntax p::STOP) () #f)
|
|
(define-struct (p:require p::STOP) () #f)
|
|
(define-struct (p:require-for-syntax p::STOP) () #f)
|
|
(define-struct (p:require-for-template p::STOP) () #f)
|
|
(define-struct (p:provide p::STOP) () #f)
|
|
|
|
;; for stop expander
|
|
(define-struct (p:stop p::STOP) () #f)
|
|
;; for early primitive errors
|
|
(define-struct (p:unknown p::STOP) () #f)
|
|
|
|
;; Module stuff.... hairy
|
|
(define-struct (p:module prule) (one-body-form? body) #f)
|
|
(define-struct (p:#%module-begin prule) (pass1 pass2) #f)
|
|
;; where pass1 is a ModPass1
|
|
;; and pass2 is a ModPass2
|
|
|
|
;; Artificial Rename
|
|
;; FIXME: Go back and add more info later, such as rename-identity
|
|
(define-struct (p:rename prule) (renames inner) #f)
|
|
|
|
;; Synthetic primitive
|
|
(define-struct (p:synth prule) (subterms) #f)
|
|
;; where subterms is list-of-Subterm
|
|
|
|
;; A Subterm is one of
|
|
;; - (make-s:subterm Path Derivation)
|
|
;; - (make-s:rename Path Syntax Syntax)
|
|
(define-struct s:subterm (path deriv) #f)
|
|
(define-struct s:rename (path before after) #f)
|
|
|
|
;; A ListDerivation is (make-lderiv Syntaxes Syntaxes (listof Derivation))
|
|
(define-struct lderiv (es1 es2 derivs) #f)
|
|
|
|
;; A BlockDerivation is (make-bderiv syntax-list syntax-list BlockPass1 Transition LDeriv)
|
|
;; where Transition = (union 'letrec 'list)
|
|
(define-struct bderiv (es1 es2 pass1 trans pass2) #f)
|
|
|
|
;; A BlockPass1 is list-of-BRule
|
|
;; A BRule is one of
|
|
;; - (make-b:defvals BlockRename Derivation/#f)
|
|
;; - (make-b:devstx BlockRename Derivation Derivation)
|
|
;; - (make-b:splice BlockRename Derivation Syntaxes)
|
|
;; - (make-b:expr BlockRename Derivation)
|
|
;; - (make-b:begin BlockRename Derivation List-of-BRule)
|
|
;; This last only used in macro-hiding
|
|
;; A BlockRename is (cons syntax syntax)
|
|
;; It always applies only to the current block element
|
|
|
|
(define-struct brule (renames) #f)
|
|
(define-struct (b:defvals brule) (head) #f)
|
|
(define-struct (b:defstx brule) (deriv rhs) #f)
|
|
(define-struct (b:splice brule) (head tail) #f)
|
|
(define-struct (b:expr brule) (head) #f)
|
|
(define-struct (b:begin brule) (head inner) #f)
|
|
|
|
;; A ModPass1 is a list of ModRule1
|
|
;; A ModRule1 is one of
|
|
;; - (make-mod:prim Derivation ModPrim)
|
|
;; - (make-mod:splice Derivation tail)
|
|
;; - (make-mod:lift Derivation tail)
|
|
;; - (make-mod:begin Derivation (list-of ModRule1))
|
|
|
|
;; A ModPrim is a PRule in:
|
|
;; - (make-p:define-values syntax syntax () #f)
|
|
;; - (make-p:define-syntaxes syntax syntax () Derivation)
|
|
;; - (make-p:require syntax syntax ())
|
|
;; - (make-p:require-for-syntax syntax syntax ())
|
|
;; - (make-p:require-for-template syntax syntax ())
|
|
;; - (make-p:provide syntax syntax ())
|
|
;; - #f
|
|
|
|
;; A ModPass2 is a list of ModRule2
|
|
;; A ModRule2 is one of
|
|
;; - (make-mod:skip)
|
|
;; - (make-mod:cons Derivation)
|
|
;; - (make-mod:lift Derivation syntaxes)
|
|
|
|
(define-struct modrule () #f)
|
|
(define-struct (mod:cons modrule) (head) #f)
|
|
(define-struct (mod:prim modrule) (head prim) #f)
|
|
(define-struct (mod:skip modrule) () #f)
|
|
(define-struct (mod:splice modrule) (head tail) #f)
|
|
(define-struct (mod:lift modrule) (head tail) #f)
|
|
(define-struct (mod:lift-end modrule) (tail) #f)
|
|
(define-struct (mod:begin modrule) (head inner) #f)
|
|
|
|
;; Handling Syntax Errors
|
|
;; ----------------------
|
|
|
|
;; An interrupted node is (make-interrupted-wrap symbol node)
|
|
;; where node is one of Derivation, ListDerivation, BlockDerivation,
|
|
;; PRule, MRule, BRule, or ModRule
|
|
(define-struct interrupted-wrap (tag inner) #f)
|
|
|
|
;; An error-wrapped node is (make-error-wrap exception symbol node)
|
|
;; where node is one of PRule, MRule, BRule, or ModRule
|
|
(define-struct error-wrap (exn tag inner) #f)
|
|
|
|
)
|