adjust for new syntax-object representation and marshaling

compiler-lib/compiler/decompile.rkt

@@ -141,39 +141,9 @@
                           [(box? datum)
                            (box (decompile-stx (unbox datum) stx-ht))]
                           [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]))))
 
-(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)
   (cond
    [(symbol? modidx) modidx]
@@ -352,7 +322,7 @@
     [(struct topsyntax (depth pos midpt))
      (list-ref/protect (glob-desc-vars globs) (+ midpt pos) 'topsyntax)]
     [(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?))
      `(set! ,(decompile-expr id globs stack closed)
             ,(decompile-expr rhs globs stack closed))]
@@ -427,11 +397,8 @@
      `(begin ,@(for/list ([expr (in-list exprs)])
                  (decompile-expr expr globs stack closed)))]
     [(struct beg0 (exprs))
-     (if (> (length exprs) 1)
      `(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))
      `(with-continuation-mark
           ,(decompile-expr key globs stack closed)

zo-lib/compiler/zo-parse.rkt

@@ -372,8 +372,7 @@
     [(27) 'inline-variant-type]
     [(35) '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)]))
 
 (define type-readers
@@ -485,8 +484,10 @@
     [33 delayed]
     [34 prefab]
     [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]
     [92 ,(+ 92 small-list-max) small-proper-list]
     [,(+ 92 small-list-max) 192 small-list]
@@ -573,6 +574,7 @@
   (arithmetic-shift a b))
 
 (define-struct not-ready ())
+(define-struct in-progress ())
 
 ;; ----------------------------------------
 ;; Syntax unmarshaling
@@ -582,15 +584,7 @@
 (define-syntax-rule (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)
-  (with-memo stx-memo v
-    (if (integer? v)
-        (unmarshal-stx-get/decode cp v decode-stx) 
   (let loop ([v v])
     (let-values ([(tamper-status v encoded-wraps)
                   (match v
@@ -651,64 +645,7 @@
                  make-prefab-struct 
                  k
                  (map loop (struct->list v)))))]
-                [else (add-wrap v)])))))))
+         [else (add-wrap v)])))))
-
-(define wrape-memo (make-memo))
-(define (decode-wrape cp a)
-  (define (aloop a) (decode-wrape cp a))
-  (with-memo wrape-memo a
-    ; A wrap-elem is either
-    (cond
-      ; A reference 
-      [(integer? a) 
-       (unmarshal-stx-get/decode cp a (lambda (cp v) (aloop 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)
   (or (and (list? v) (andmap exact-integer? v))
@@ -736,13 +673,8 @@
         (parse-module-path-index cp path)
         phase src-phase null #f null)])))
 
-(define wraps-memo (make-memo))
 (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)
   (make-do-sequence
@@ -814,7 +746,7 @@
       (case cpt-tag
         [(delayed)
          (let ([pos (read-compact-number cp)])
-           (read-sym cp pos))]
+           (read-symref cp pos #t 'delayed))]
         [(escape)
          (let* ([len (read-compact-number cp)]
                 [s (cport-get-bytes cp len)])
@@ -978,7 +910,7 @@
                     (read-compact cp)))))]
         [(marshalled) (read-marshalled (read-compact-number cp) cp)]
         [(stx)
-         (let ([v (make-reader-graph (read-compact cp))])
+         (let ([v (read-compact cp)])
            (make-stx (decode-stx cp v)))]
         [(local local-unbox)
          (let ([c (read-compact-number cp)]
@@ -1024,7 +956,7 @@
               (read (open-input-bytes #"x")))))]
         [(symref)
          (let* ([l (read-compact-number cp)])
-           (read-sym cp l))]
+           (read-symref cp l #t 'symref))]
         [(weird-symbol)
          (let ([uninterned (read-compact-number cp)]
                [str (read-compact-chars cp (read-compact-number cp))])
@@ -1053,8 +985,11 @@
                              (for/list ([i (in-range c)])
                                (read-compact cp))))]
         [(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
             v
             (gensym
@@ -1062,11 +997,21 @@
                (cond
                  [(symbol? s) s]
                  [(vector? s) (vector-ref s 0)]
-                 [else 'closure])))))]
+                 [else 'closure])))))
+         (placeholder-set! ph r)
+         r]
         [(svector)
          (read-compact-svector cp (read-compact-number cp))]
         [(small-svector)
          (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)]))
     (cond
       [(zero? need-car) v]
@@ -1075,40 +1020,36 @@
       [else
        (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)
-  (placeholder-set! (vector-ref (cport-symtab cp) i) v))
+  (vector-set! (cport-symtab cp) i v))
 
 (define (symtab-lookup 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))
+  (cond
+   [(not-ready? v)
+    (when mark-in-progress?
+      (symtab-write! cp i (in-progress)))
+    (define save-pos (cport-pos cp))
     (set-cport-pos! cp (vector-ref (cport-shared-offsets cp) (sub1 i)))
-            (mark-parameterize
+    (define v (read-compact cp))
-             ([read-sym-mark i])
+    (symtab-write! cp i v)
-             (let ([v (read-compact cp)])
+    (set-cport-pos! cp save-pos)
-               (placeholder-set! ph v)))
+    v]
-            (set-cport-pos! cp save-pos)))
+   [(in-progress? v)
-        (placeholder-get ph))))
+    (error who "unexpected cycle in input")]
+   [else v]))
 
 (define (read-prefix port)
   ;; skip the "#~"
@@ -1233,16 +1174,14 @@
     (unless (eof-object? (read-byte port))
       (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
     (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)])
-    (read-sym cp i))
+    (read-symref cp i #f 'table))
 
   #;(printf "Parsed table:\n")
   #;(for ([(i v) (in-dict (cport-symtab cp))])

zo-lib/compiler/zo-structs.rkt

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