suzanne.soy/racket
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

adjust for new syntax-object representation and marshaling

Browse Source
This commit is contained in:
Matthew Flatt 2015-02-26 10:09:56 -07:00
parent 3da4b863cf
commit 86a410dc0c
3 changed files with 119 additions and 213 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
compiler-lib/compiler/decompile.rkt
View File

@ -141,39 +141,9 @@
[(box? datum) [(box? datum)
(box (decompile-stx (unbox datum) stx-ht))] (box (decompile-stx (unbox datum) stx-ht))]
[else datum]) [else datum])
(let loop ([wraps wraps]) wraps))
(cond
[(null? wraps) null]
[else
(or (hash-ref stx-ht wraps #f)
(let ([p (mcons #f #f)])
(hash-set! stx-ht wraps p)
(set-mcar! p (decompile-wrap (car wraps) stx-ht))
(set-mcdr! p (loop (cdr wraps)))
p))]))))
p])))) p]))))
(define (decompile-wrap w stx-ht)
(or (hash-ref stx-ht w #f)
(let ([v (match w
[(lexical-rename has-free-id-renames?
ignored
alist)
`(,(if has-free-id-renames? 'lexical/free-id=? 'lexical) . ,alist)]
[(phase-shift amt src dest cancel-id)
`(phase-shift ,amt ,src ,dest, cancel-id)]
[(wrap-mark val)
val]
[(prune sym)
`(prune ,sym)]
[(module-rename phase kind set-id unmarshals renames mark-renames plus-kern?)
`(module-rename ,phase ,kind ,set-id ,unmarshals ,renames ,mark-renames ,plus-kern?)]
[(top-level-rename flag)
`(top-level-rename ,flag)]
[else w])])
(hash-set! stx-ht w v)
v)))
(define (mpi->string modidx) (define (mpi->string modidx)
(cond (cond
[(symbol? modidx) modidx] [(symbol? modidx) modidx]
@ -352,7 +322,7 @@
[(struct topsyntax (depth pos midpt)) [(struct topsyntax (depth pos midpt))
(list-ref/protect (glob-desc-vars globs) (+ midpt pos) 'topsyntax)] (list-ref/protect (glob-desc-vars globs) (+ midpt pos) 'topsyntax)]
[(struct primval (id)) [(struct primval (id))
(hash-ref primitive-table id (lambda () (error "unknown primitive")))] (hash-ref primitive-table id (lambda () (error "unknown primitive: " id)))]
[(struct assign (id rhs undef-ok?)) [(struct assign (id rhs undef-ok?))
`(set! ,(decompile-expr id globs stack closed) `(set! ,(decompile-expr id globs stack closed)
,(decompile-expr rhs globs stack closed))] ,(decompile-expr rhs globs stack closed))]
@ -427,11 +397,8 @@
`(begin ,@(for/list ([expr (in-list exprs)]) `(begin ,@(for/list ([expr (in-list exprs)])
(decompile-expr expr globs stack closed)))] (decompile-expr expr globs stack closed)))]
[(struct beg0 (exprs)) [(struct beg0 (exprs))
(if (> (length exprs) 1) `(begin0 ,@(for/list ([expr (in-list exprs)])
`(begin0 ,@(for/list ([expr (in-list exprs)]) (decompile-expr expr globs stack closed)))]
(decompile-expr expr globs stack closed)))
`(begin0 ,(decompile-expr (car exprs) globs stack closed)
(void)))]
[(struct with-cont-mark (key val body)) [(struct with-cont-mark (key val body))
`(with-continuation-mark `(with-continuation-mark
,(decompile-expr key globs stack closed) ,(decompile-expr key globs stack closed)

289
zo-lib/compiler/zo-parse.rkt
View File

@ -372,8 +372,7 @@
[(27) 'inline-variant-type] [(27) 'inline-variant-type]
[(35) 'variable-type] [(35) 'variable-type]
[(36) 'module-variable-type] [(36) 'module-variable-type]
[(114) 'resolve-prefix-type] [(115) 'resolve-prefix-type]
[(164) 'free-id-info-type]
[else (error 'int->type "unknown type: ~e" i)])) [else (error 'int->type "unknown type: ~e" i)]))
(define type-readers (define type-readers
@ -485,8 +484,10 @@
[33 delayed] [33 delayed]
[34 prefab] [34 prefab]
[35 let-one-unused] [35 let-one-unused]
[36 60 small-number] [36 mark]
[60 80 small-symbol] [37 shared]
[38 62 small-number]
[62 80 small-symbol]
[80 92 small-marshalled] [80 92 small-marshalled]
[92 ,(+ 92 small-list-max) small-proper-list] [92 ,(+ 92 small-list-max) small-proper-list]
[,(+ 92 small-list-max) 192 small-list] [,(+ 92 small-list-max) 192 small-list]
@ -573,6 +574,7 @@
(arithmetic-shift a b)) (arithmetic-shift a b))
(define-struct not-ready ()) (define-struct not-ready ())
(define-struct in-progress ())
;; ---------------------------------------- ;; ----------------------------------------
;; Syntax unmarshaling ;; Syntax unmarshaling
@ -582,133 +584,68 @@
(define-syntax-rule (with-memo mt arg body ...) (define-syntax-rule (with-memo mt arg body ...)
(with-memo* mt arg (λ () body ...))) (with-memo* mt arg (λ () body ...)))
(define (decode-mark-map alist)
alist)
(define stx-memo (make-memo))
; XXX More memo use
(define (decode-stx cp v) (define (decode-stx cp v)
(with-memo stx-memo v (let loop ([v v])
(if (integer? v) (let-values ([(tamper-status v encoded-wraps)
(unmarshal-stx-get/decode cp v decode-stx) (match v
(let loop ([v v]) [`#((,datum . ,wraps)) (values 'tainted datum wraps)]
(let-values ([(tamper-status v encoded-wraps) [`#((,datum . ,wraps) #f) (values 'armed datum wraps)]
(match v [`(,datum . ,wraps) (values 'clean datum wraps)]
[`#((,datum . ,wraps)) (values 'tainted datum wraps)] [else (error 'decode-wraps "bad datum+wrap: ~.s" v)])])
[`#((,datum . ,wraps) #f) (values 'armed datum wraps)] (let* ([wraps (decode-wraps cp encoded-wraps)]
[`(,datum . ,wraps) (values 'clean datum wraps)] [wrapped-memo (make-memo)]
[else (error 'decode-wraps "bad datum+wrap: ~.s" v)])]) [add-wrap (lambda (v) (with-memo wrapped-memo v (make-wrapped v wraps tamper-status)))])
(let* ([wraps (decode-wraps cp encoded-wraps)] (cond
[wrapped-memo (make-memo)] [(pair? v)
[add-wrap (lambda (v) (with-memo wrapped-memo v (make-wrapped v wraps tamper-status)))]) (if (eq? #t (car v))
(cond ;; Share decoded wraps with all nested parts.
[(pair? v) (let iloop ([v (cdr v)])
(if (eq? #t (car v)) (cond
;; Share decoded wraps with all nested parts. [(pair? v)
(let iloop ([v (cdr v)]) (let ploop ([v v])
(cond (cond
[(pair? v) [(null? v) null]
(let ploop ([v v]) [(pair? v) (add-wrap (cons (iloop (car v)) (ploop (cdr v))))]
(cond [else (iloop v)]))]
[(null? v) null] [(box? v) (add-wrap (box (iloop (unbox v))))]
[(pair? v) (add-wrap (cons (iloop (car v)) (ploop (cdr v))))] [(vector? v)
[else (iloop v)]))] (add-wrap (list->vector (map iloop (vector->list v))))]
[(box? v) (add-wrap (box (iloop (unbox v))))] [(hash? v)
[(vector? v) (add-wrap (for/hash ([(k v) (in-hash v)])
(add-wrap (list->vector (map iloop (vector->list v))))] (values k (iloop v))))]
[(hash? v) [(prefab-struct-key v)
(add-wrap (for/hash ([(k v) (in-hash v)]) => (lambda (k)
(values k (iloop v))))]
[(prefab-struct-key v)
=> (lambda (k)
(add-wrap
(apply
make-prefab-struct
k
(map iloop (struct->list v)))))]
[else (add-wrap v)]))
;; Decode sub-elements that have their own wraps:
(let-values ([(v counter) (if (exact-integer? (car v))
(values (cdr v) (car v))
(values v -1))])
(add-wrap (add-wrap
(let ploop ([v v][counter counter]) (apply
(cond make-prefab-struct
[(null? v) null] k
[(or (not (pair? v)) (zero? counter)) (loop v)] (map iloop (struct->list v)))))]
[(pair? v) (cons (loop (car v)) [else (add-wrap v)]))
(ploop (cdr v) (sub1 counter)))])))))] ;; Decode sub-elements that have their own wraps:
[(box? v) (add-wrap (box (loop (unbox v))))] (let-values ([(v counter) (if (exact-integer? (car v))
[(vector? v) (values (cdr v) (car v))
(add-wrap (list->vector (map loop (vector->list v))))] (values v -1))])
[(hash? v) (add-wrap
(add-wrap (for/hash ([(k v) (in-hash v)]) (let ploop ([v v][counter counter])
(values k (loop v))))] (cond
[(prefab-struct-key v) [(null? v) null]
=> (lambda (k) [(or (not (pair? v)) (zero? counter)) (loop v)]
(add-wrap [(pair? v) (cons (loop (car v))
(apply (ploop (cdr v) (sub1 counter)))])))))]
make-prefab-struct [(box? v) (add-wrap (box (loop (unbox v))))]
k [(vector? v)
(map loop (struct->list v)))))] (add-wrap (list->vector (map loop (vector->list v))))]
[else (add-wrap v)]))))))) [(hash? v)
(add-wrap (for/hash ([(k v) (in-hash v)])
(define wrape-memo (make-memo)) (values k (loop v))))]
(define (decode-wrape cp a) [(prefab-struct-key v)
(define (aloop a) (decode-wrape cp a)) => (lambda (k)
(with-memo wrape-memo a (add-wrap
; A wrap-elem is either (apply
(cond make-prefab-struct
; A reference k
[(integer? a) (map loop (struct->list v)))))]
(unmarshal-stx-get/decode cp a (lambda (cp v) (aloop v)))] [else (add-wrap v)])))))
; A mark wraped in a list
[(and (pair? a) (number? (car a)) (null? (cdr a)))
(make-wrap-mark (car a))]
[(vector? a)
(make-lexical-rename (vector-ref a 0) (vector-ref a 1)
(let ([top (+ (/ (- (vector-length a) 2) 2) 2)])
(let loop ([i 2])
(if (= i top)
null
(cons (cons (vector-ref a i)
(vector-ref a (+ (- top 2) i)))
(loop (+ i 1)))))))]
[(pair? a)
(let-values ([(plus-kern? a) (if (eq? (car a) #t)
(values #t (cdr a))
(values #f a))])
(match a
[`(,phase ,kind ,set-id ,maybe-unmarshals . ,renames)
(let-values ([(unmarshals renames mark-renames)
(if (vector? maybe-unmarshals)
(values null maybe-unmarshals renames)
(values maybe-unmarshals
(car renames)
(cdr renames)))])
(make-module-rename phase
(if kind 'marked 'normal)
set-id
(map (curry decode-all-from-module cp) unmarshals)
(decode-renames renames)
mark-renames
(and plus-kern? 'plus-kern)))]
[else (error "bad module rename: ~e" a)]))]
[(boolean? a)
(make-top-level-rename a)]
[(symbol? a)
(make-mark-barrier a)]
[(box? a)
(match (unbox a)
[(list (? symbol?) ...) (make-prune (unbox a))]
[`#(,amt ,src ,dest #f #f ,cancel-id)
(make-phase-shift amt
(parse-module-path-index cp src)
(parse-module-path-index cp dest)
cancel-id)]
[else (error 'parse "bad phase shift: ~e" a)])]
[else (error 'decode-wraps "bad wrap element: ~e" a)])))
(define (afm-context? v) (define (afm-context? v)
(or (and (list? v) (andmap exact-integer? v)) (or (and (list? v) (andmap exact-integer? v))
@ -736,13 +673,8 @@
(parse-module-path-index cp path) (parse-module-path-index cp path)
phase src-phase null #f null)]))) phase src-phase null #f null)])))
(define wraps-memo (make-memo))
(define (decode-wraps cp w) (define (decode-wraps cp w)
(with-memo wraps-memo w w)
; A wraps is either a indirect reference or a list of wrap-elems (from stxobj.c:252)
(if (integer? w)
(unmarshal-stx-get/decode cp w decode-wraps)
(map (curry decode-wrape cp) w))))
(define (in-vector* v n) (define (in-vector* v n)
(make-do-sequence (make-do-sequence
@ -814,7 +746,7 @@
(case cpt-tag (case cpt-tag
[(delayed) [(delayed)
(let ([pos (read-compact-number cp)]) (let ([pos (read-compact-number cp)])
(read-sym cp pos))] (read-symref cp pos #t 'delayed))]
[(escape) [(escape)
(let* ([len (read-compact-number cp)] (let* ([len (read-compact-number cp)]
[s (cport-get-bytes cp len)]) [s (cport-get-bytes cp len)])
@ -978,7 +910,7 @@
(read-compact cp)))))] (read-compact cp)))))]
[(marshalled) (read-marshalled (read-compact-number cp) cp)] [(marshalled) (read-marshalled (read-compact-number cp) cp)]
[(stx) [(stx)
(let ([v (make-reader-graph (read-compact cp))]) (let ([v (read-compact cp)])
(make-stx (decode-stx cp v)))] (make-stx (decode-stx cp v)))]
[(local local-unbox) [(local local-unbox)
(let ([c (read-compact-number cp)] (let ([c (read-compact-number cp)]
@ -1024,7 +956,7 @@
(read (open-input-bytes #"x")))))] (read (open-input-bytes #"x")))))]
[(symref) [(symref)
(let* ([l (read-compact-number cp)]) (let* ([l (read-compact-number cp)])
(read-sym cp l))] (read-symref cp l #t 'symref))]
[(weird-symbol) [(weird-symbol)
(let ([uninterned (read-compact-number cp)] (let ([uninterned (read-compact-number cp)]
[str (read-compact-chars cp (read-compact-number cp))]) [str (read-compact-chars cp (read-compact-number cp))])
@ -1053,8 +985,11 @@
(for/list ([i (in-range c)]) (for/list ([i (in-range c)])
(read-compact cp))))] (read-compact cp))))]
[(closure) [(closure)
(read-compact-number cp) ; symbol table pos. our marshaler will generate this (define pos (read-compact-number cp))
(let ([v (read-compact cp)]) (define ph (make-placeholder 'closure))
(symtab-write! cp pos ph)
(define v (read-compact cp))
(define r
(make-closure (make-closure
v v
(gensym (gensym
@ -1062,11 +997,21 @@
(cond (cond
[(symbol? s) s] [(symbol? s) s]
[(vector? s) (vector-ref s 0)] [(vector? s) (vector-ref s 0)]
[else 'closure])))))] [else 'closure])))))
(placeholder-set! ph r)
r]
[(svector) [(svector)
(read-compact-svector cp (read-compact-number cp))] (read-compact-svector cp (read-compact-number cp))]
[(small-svector) [(small-svector)
(read-compact-svector cp (- ch cpt-start))] (read-compact-svector cp (- ch cpt-start))]
[(mark)
(let ([pos (read-compact-number cp)])
(if (zero? pos)
(box (read-compact cp))
(read-cyclic cp pos 'mark box)))]
[(shared)
(let ([pos (read-compact-number cp)])
(read-cyclic cp pos 'shared))]
[else (error 'read-compact "unknown tag ~a" cpt-tag)])) [else (error 'read-compact "unknown tag ~a" cpt-tag)]))
(cond (cond
[(zero? need-car) v] [(zero? need-car) v]
@ -1075,40 +1020,36 @@
[else [else
(cons v (loop (sub1 need-car) proper))]))) (cons v (loop (sub1 need-car) proper))])))
(define (unmarshal-stx-get/decode cp pos decode-stx)
(define v2 (read-sym cp pos))
(define decoded? (vector-ref (cport-decoded cp) pos))
(if decoded?
v2
(let ([dv2 (decode-stx cp v2)])
(symtab-write! cp pos dv2)
(vector-set! (cport-decoded cp) pos #t)
dv2)))
(define (symtab-write! cp i v) (define (symtab-write! cp i v)
(placeholder-set! (vector-ref (cport-symtab cp) i) v)) (vector-set! (cport-symtab cp) i v))
(define (symtab-lookup cp i) (define (symtab-lookup cp i)
(vector-ref (cport-symtab cp) i)) (vector-ref (cport-symtab cp) i))
(require unstable/markparam) (define (read-cyclic cp i who [wrap values])
(define read-sym-mark (mark-parameter)) (define v (symtab-lookup cp i))
(define (read-sym cp i) (define ph (make-placeholder (not-ready)))
(define ph (symtab-lookup cp i)) (symtab-write! cp i ph)
; We are reading this already, so return the placeholder (define r (wrap (read-compact cp)))
(if (memq i (mark-parameter-all read-sym-mark)) (when (eq? r ph) (error who "unresolvable cyclic data"))
ph (placeholder-set! ph r)
; Otherwise, try to read it and return the real thing ph)
(let ([vv (placeholder-get ph)])
(when (not-ready? vv) (define (read-symref cp i mark-in-progress? who)
(let ([save-pos (cport-pos cp)]) (define v (symtab-lookup cp i))
(set-cport-pos! cp (vector-ref (cport-shared-offsets cp) (sub1 i))) (cond
(mark-parameterize [(not-ready? v)
([read-sym-mark i]) (when mark-in-progress?
(let ([v (read-compact cp)]) (symtab-write! cp i (in-progress)))
(placeholder-set! ph v))) (define save-pos (cport-pos cp))
(set-cport-pos! cp save-pos))) (set-cport-pos! cp (vector-ref (cport-shared-offsets cp) (sub1 i)))
(placeholder-get ph)))) (define v (read-compact cp))
(symtab-write! cp i v)
(set-cport-pos! cp save-pos)
v]
[(in-progress? v)
(error who "unexpected cycle in input")]
[else v]))
(define (read-prefix port) (define (read-prefix port)
;; skip the "#~" ;; skip the "#~"
@ -1233,16 +1174,14 @@
(unless (eof-object? (read-byte port)) (unless (eof-object? (read-byte port))
(error 'zo-parse "File too big"))) (error 'zo-parse "File too big")))
(define nr (make-not-ready)) (define symtab (make-vector symtabsize (not-ready)))
(define symtab
(build-vector symtabsize (λ (i) (make-placeholder nr))))
(define cp (define cp
(make-cport 0 shared-size port size* rst-start symtab so* (make-cport 0 shared-size port size* rst-start symtab so*
(make-vector symtabsize #f) (make-hash) (make-hash))) (make-vector symtabsize (not-ready)) (make-hash) (make-hash)))
(for ([i (in-range 1 symtabsize)]) (for ([i (in-range 1 symtabsize)])
(read-sym cp i)) (read-symref cp i #f 'table))
#;(printf "Parsed table:\n") #;(printf "Parsed table:\n")
#;(for ([(i v) (in-dict (cport-symtab cp))]) #;(for ([(i v) (in-dict (cport-symtab cp))])

2
zo-lib/compiler/zo-structs.rkt
View File

@ -73,7 +73,7 @@
(define-form-struct wrap ()) (define-form-struct wrap ())
(define-form-struct wrapped ([datum any/c] (define-form-struct wrapped ([datum any/c]
[wraps (listof wrap?)] [wraps any/c]
[tamper-status (or/c 'clean 'armed 'tainted)])) [tamper-status (or/c 'clean 'armed 'tainted)]))
;; In stxs of prefix: ;; In stxs of prefix: