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

removing indirects from zo handling

Browse Source
This commit is contained in:
Blake Johnson 2010-09-16 12:13:15 -06:00 committed by Jay McCarthy
parent 4f49658835
commit c88eb704c7
6 changed files with 76 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
collects/compiler/decompile.rkt
View File

@ -160,8 +160,6 @@
(extract-name name)] (extract-name name)]
[(struct closure (lam gen-id)) [(struct closure (lam gen-id))
(extract-id lam)] (extract-id lam)]
[(struct indirect (v))
(extract-id v)]
[else #f])) [else #f]))
(define (extract-ids! body ids) (define (extract-ids! body ids)
@ -288,15 +286,10 @@
(begin (begin
(hash-set! closed gen-id #t) (hash-set! closed gen-id #t)
`(#%closed ,gen-id ,(decompile-expr lam globs stack closed))))] `(#%closed ,gen-id ,(decompile-expr lam globs stack closed))))]
[(struct indirect (val))
(if (closure? val)
(decompile-expr val globs stack closed)
'???)]
[else `(quote ,expr)])) [else `(quote ,expr)]))
(define (decompile-lam expr globs stack closed) (define (decompile-lam expr globs stack closed)
(match expr (match expr
[(struct indirect (val)) (decompile-lam val globs stack closed)]
[(struct closure (lam gen-id)) (decompile-lam lam globs stack closed)] [(struct closure (lam gen-id)) (decompile-lam lam globs stack closed)]
[(struct lam (name flags num-params arg-types rest? closure-map closure-types max-let-depth body)) [(struct lam (name flags num-params arg-types rest? closure-map closure-types max-let-depth body))
(let ([vars (for/list ([i (in-range num-params)] (let ([vars (for/list ([i (in-range num-params)]

2
collects/compiler/zo-marshal.rkt
View File

@ -516,8 +516,6 @@
(unless (zero? phase) (unless (zero? phase)
(out-number -2 out)) (out-number -2 out))
(out-number pos out)] (out-number pos out)]
[(struct indirect (val))
(out-anything val out)]
[(struct closure (lam gen-id)) [(struct closure (lam gen-id))
(out-byte CPT_CLOSURE out) (out-byte CPT_CLOSURE out)
(let ([pos ((out-shared-index out) v #:error? #t)]) (let ([pos ((out-shared-index out) v #:error? #t)])

42
collects/compiler/zo-parse.rkt
View File

@ -348,9 +348,9 @@
(cons 'free-id-info-type read-free-id-info)))) (cons 'free-id-info-type read-free-id-info))))
(define (get-reader type) (define (get-reader type)
(or (hash-ref type-readers type #f) (hash-ref type-readers type
(lambda (v) (λ ()
(error 'read-marshalled "reader for ~a not implemented" type)))) (error 'read-marshalled "reader for ~a not implemented" type))))
;; ---------------------------------------- ;; ----------------------------------------
;; Lowest layer of bytecode parsing ;; Lowest layer of bytecode parsing
@ -732,6 +732,9 @@
(define (parse-module-path-index cp s) (define (parse-module-path-index cp s)
s) s)
(define (error-when-false v)
(or v (error "app rator is false")))
;; ---------------------------------------- ;; ----------------------------------------
;; Main parsing loop ;; Main parsing loop
@ -927,7 +930,7 @@
[(small-marshalled) [(small-marshalled)
(read-marshalled (- ch cpt-start) cp)] (read-marshalled (- ch cpt-start) cp)]
[(small-application2) [(small-application2)
(make-application (read-compact cp) (make-application (error-when-false (read-compact cp))
(list (read-compact cp)))] (list (read-compact cp)))]
[(small-application3) [(small-application3)
(make-application (read-compact cp) (make-application (read-compact cp)
@ -935,29 +938,26 @@
(read-compact cp)))] (read-compact cp)))]
[(small-application) [(small-application)
(let ([c (add1 (- ch cpt-start))]) (let ([c (add1 (- ch cpt-start))])
(make-application (read-compact cp) (make-application (error-when-false (read-compact cp))
(for/list ([i (in-range (sub1 c))]) (for/list ([i (in-range (sub1 c))])
(read-compact cp))))] (read-compact cp))))]
[(application) [(application)
(let ([c (read-compact-number cp)]) (let ([c (read-compact-number cp)])
(make-application (read-compact cp) (make-application (error-when-false (read-compact cp))
(for/list ([i (in-range c)]) (for/list ([i (in-range c)])
(read-compact cp))))] (read-compact cp))))]
[(closure) ; XXX The use of indirect may be an artifact from pre-placeholder days [(closure)
(let* ([l (read-compact-number cp)] (read-compact-number cp) ; symbol table pos. our marshaler will generate this
[ind (make-indirect #f)]) (let ([v (read-compact cp)])
(symtab-write! cp l ind) (make-closure
(let* ([v (read-compact cp)] v
[cl (make-closure v ; XXX Why call gensym here?
; XXX Why call gensym here? (gensym
(gensym (let ([s (lam-name v)])
(let ([s (lam-name v)]) (cond
(cond [(symbol? s) s]
[(symbol? s) s] [(vector? s) (vector-ref s 0)]
[(vector? s) (vector-ref s 0)] [else 'closure])))))]
[else 'closure]))))])
(set-indirect-v! ind cl)
ind))]
[(svector) [(svector)
(read-compact-svector cp (read-compact-number cp))] (read-compact-svector cp (read-compact-number cp))]
[(small-svector) [(small-svector)

52
collects/compiler/zo-structs.rkt
View File

@ -82,11 +82,7 @@
(define-form-struct form ()) (define-form-struct form ())
(define-form-struct (expr form) ()) (define-form-struct (expr form) ())
;; A static closure can refer directly to itself, creating a cycle (define-form-struct compilation-top ([max-let-depth exact-nonnegative-integer?] [prefix prefix?] [code (or/c form? any/c)])) ; compiled code always wrapped with this
; XXX: this might not be needed anymore with the current sharing model
(define-struct (indirect zo) ([v #:mutable]) #:prefab)
(define-form-struct compilation-top ([max-let-depth exact-nonnegative-integer?] [prefix prefix?] [code (or/c form? indirect? any/c)])) ; compiled code always wrapped with this
;; A provided identifier ;; A provided identifier
(define-form-struct provided ([name symbol?] (define-form-struct provided ([name symbol?]
@ -102,17 +98,17 @@
[const? boolean?] [const? boolean?]
[ready? boolean?])) ; access binding via prefix array (which is on stack) [ready? boolean?])) ; access binding via prefix array (which is on stack)
(define-form-struct (seq form) ([forms (listof (or/c form? indirect? any/c))])) ; `begin' (define-form-struct (seq form) ([forms (listof (or/c form? any/c))])) ; `begin'
;; Definitions (top level or within module): ;; Definitions (top level or within module):
(define-form-struct (def-values form) ([ids (listof (or/c toplevel? symbol?))] ; added symbol? (define-form-struct (def-values form) ([ids (listof (or/c toplevel? symbol?))] ; added symbol?
[rhs (or/c expr? seq? indirect? any/c)])) [rhs (or/c expr? seq? any/c)]))
(define-form-struct (def-syntaxes form) ([ids (listof (or/c toplevel? symbol?))] ; added symbol? (define-form-struct (def-syntaxes form) ([ids (listof (or/c toplevel? symbol?))] ; added symbol?
[rhs (or/c expr? seq? indirect? any/c)] [rhs (or/c expr? seq? any/c)]
[prefix prefix?] [prefix prefix?]
[max-let-depth exact-nonnegative-integer?])) [max-let-depth exact-nonnegative-integer?]))
(define-form-struct (def-for-syntax form) ([ids (listof (or/c toplevel? symbol?))] ; added symbol? (define-form-struct (def-for-syntax form) ([ids (listof (or/c toplevel? symbol?))] ; added symbol?
[rhs (or/c expr? seq? indirect? any/c)] [rhs (or/c expr? seq? any/c)]
[prefix prefix?] [prefix prefix?]
[max-let-depth exact-nonnegative-integer?])) [max-let-depth exact-nonnegative-integer?]))
@ -125,7 +121,7 @@
(listof provided?)))] (listof provided?)))]
[requires (listof (cons/c (or/c exact-integer? #f) [requires (listof (cons/c (or/c exact-integer? #f)
(listof module-path-index?)))] (listof module-path-index?)))]
[body (listof (or/c form? indirect? any/c))] [body (listof (or/c form? any/c))]
[syntax-body (listof (or/c def-syntaxes? def-for-syntax?))] [syntax-body (listof (or/c def-syntaxes? def-for-syntax?))]
[unexported (list/c (listof symbol?) (listof symbol?) [unexported (list/c (listof symbol?) (listof symbol?)
(listof symbol?))] (listof symbol?))]
@ -142,35 +138,35 @@
[closure-map (vectorof exact-nonnegative-integer?)] [closure-map (vectorof exact-nonnegative-integer?)]
[closure-types (listof (or/c 'val/ref 'flonum))] [closure-types (listof (or/c 'val/ref 'flonum))]
[max-let-depth exact-nonnegative-integer?] [max-let-depth exact-nonnegative-integer?]
[body (or/c expr? seq? indirect? any/c)])) ; `lambda' [body (or/c expr? seq? any/c)])) ; `lambda'
(define-form-struct (closure expr) ([code lam?] [gen-id symbol?])) ; a static closure (nothing to close over) (define-form-struct (closure expr) ([code lam?] [gen-id symbol?])) ; a static closure (nothing to close over)
(define-form-struct (case-lam expr) ([name (or/c symbol? vector? empty?)] [clauses (listof (or/c lam? indirect?))])) ; each clause is a lam (added indirect) (define-form-struct (case-lam expr) ([name (or/c symbol? vector? empty?)] [clauses (listof (or/c lam? closure?))]))
(define-form-struct (let-one expr) ([rhs (or/c expr? seq? indirect? any/c)] [body (or/c expr? seq? indirect? any/c)] [flonum? boolean?] [unused? boolean?])) ; pushes one value onto stack (define-form-struct (let-one expr) ([rhs (or/c expr? seq? any/c)] [body (or/c expr? seq? any/c)] [flonum? boolean?] [unused? boolean?])) ; pushes one value onto stack
(define-form-struct (let-void expr) ([count exact-nonnegative-integer?] [boxes? boolean?] [body (or/c expr? seq? indirect? any/c)])) ; create new stack slots (define-form-struct (let-void expr) ([count exact-nonnegative-integer?] [boxes? boolean?] [body (or/c expr? seq? any/c)])) ; create new stack slots
(define-form-struct (install-value expr) ([count exact-nonnegative-integer?] (define-form-struct (install-value expr) ([count exact-nonnegative-integer?]
[pos exact-nonnegative-integer?] [pos exact-nonnegative-integer?]
[boxes? boolean?] [boxes? boolean?]
[rhs (or/c expr? seq? indirect? any/c)] [rhs (or/c expr? seq? any/c)]
[body (or/c expr? seq? indirect? any/c)])) ; set existing stack slot(s) [body (or/c expr? seq? any/c)])) ; set existing stack slot(s)
(define-form-struct (let-rec expr) ([procs (listof lam?)] [body (or/c expr? seq? indirect? any/c)])) ; put `letrec'-bound closures into existing stack slots (define-form-struct (let-rec expr) ([procs (listof lam?)] [body (or/c expr? seq? any/c)])) ; put `letrec'-bound closures into existing stack slots
(define-form-struct (boxenv expr) ([pos exact-nonnegative-integer?] [body (or/c expr? seq? indirect? any/c)])) ; box existing stack element (define-form-struct (boxenv expr) ([pos exact-nonnegative-integer?] [body (or/c expr? seq? any/c)])) ; box existing stack element
(define-form-struct (localref expr) ([unbox? boolean?] [pos exact-nonnegative-integer?] [clear? boolean?] [other-clears? boolean?] [flonum? boolean?])) ; access local via stack (define-form-struct (localref expr) ([unbox? boolean?] [pos exact-nonnegative-integer?] [clear? boolean?] [other-clears? boolean?] [flonum? boolean?])) ; access local via stack
(define-form-struct (topsyntax expr) ([depth exact-nonnegative-integer?] [pos exact-nonnegative-integer?] [midpt exact-nonnegative-integer?])) ; access syntax object via prefix array (which is on stack) (define-form-struct (topsyntax expr) ([depth exact-nonnegative-integer?] [pos exact-nonnegative-integer?] [midpt exact-nonnegative-integer?])) ; access syntax object via prefix array (which is on stack)
(define-form-struct (application expr) ([rator (or/c expr? seq? indirect? any/c)] [rands (listof (or/c expr? seq? indirect? any/c))])) ; function call (define-form-struct (application expr) ([rator (or/c expr? seq? any/c)] [rands (listof (or/c expr? seq? any/c))])) ; function call
(define-form-struct (branch expr) ([test (or/c expr? seq? indirect? any/c)] [then (or/c expr? seq? indirect? any/c)] [else (or/c expr? seq? indirect? any/c)])) ; `if' (define-form-struct (branch expr) ([test (or/c expr? seq? any/c)] [then (or/c expr? seq? any/c)] [else (or/c expr? seq? any/c)])) ; `if'
(define-form-struct (with-cont-mark expr) ([key (or/c expr? seq? indirect? any/c)] (define-form-struct (with-cont-mark expr) ([key (or/c expr? seq? any/c)]
[val (or/c expr? seq? indirect? any/c)] [val (or/c expr? seq? any/c)]
[body (or/c expr? seq? indirect? any/c)])) ; `with-continuation-mark' [body (or/c expr? seq? any/c)])) ; `with-continuation-mark'
(define-form-struct (beg0 expr) ([seq (listof (or/c expr? seq? indirect? any/c))])) ; `begin0' (define-form-struct (beg0 expr) ([seq (listof (or/c expr? seq? any/c))])) ; `begin0'
(define-form-struct (splice form) ([forms (listof (or/c form? indirect? any/c))])) ; top-level `begin' (define-form-struct (splice form) ([forms (listof (or/c form? any/c))])) ; top-level `begin'
(define-form-struct (varref expr) ([toplevel toplevel?])) ; `#%variable-reference' (define-form-struct (varref expr) ([toplevel toplevel?])) ; `#%variable-reference'
(define-form-struct (assign expr) ([id toplevel?] [rhs (or/c expr? seq? indirect? any/c)] [undef-ok? boolean?])) ; top-level or module-level set! (define-form-struct (assign expr) ([id toplevel?] [rhs (or/c expr? seq? any/c)] [undef-ok? boolean?])) ; top-level or module-level set!
(define-form-struct (apply-values expr) ([proc (or/c expr? seq? indirect? any/c)] [args-expr (or/c expr? seq? indirect? any/c)])) ; `(call-with-values (lambda () ,args-expr) ,proc) (define-form-struct (apply-values expr) ([proc (or/c expr? seq? any/c)] [args-expr (or/c expr? seq? any/c)])) ; `(call-with-values (lambda () ,args-expr) ,proc)
(define-form-struct (primval expr) ([id exact-nonnegative-integer?])) ; direct preference to a kernel primitive (define-form-struct (primval expr) ([id exact-nonnegative-integer?])) ; direct preference to a kernel primitive
;; Top-level `require' ;; Top-level `require'
@ -245,8 +241,6 @@
; XXX better name for 'value' ; XXX better name for 'value'
(define-form-struct (mark-barrier wrap) ([value symbol?])) (define-form-struct (mark-barrier wrap) ([value symbol?]))
(provide/contract (struct indirect ([v (or/c closure? #f)])))

70
collects/scribblings/raco/zo-parse.scrbl
View File

@ -79,7 +79,7 @@ A supertype for all zo objects that can appear in compiled code.}
@defstruct+[(compilation-top zo) ([max-let-depth exact-nonnegative-integer?] @defstruct+[(compilation-top zo) ([max-let-depth exact-nonnegative-integer?]
[prefix prefix?] [prefix prefix?]
[code (or/c form? indirect? any/c)])]{ [code (or/c form? any/c)])]{
Wraps compiled code. The @racket[max-let-depth] field indicates the Wraps compiled code. The @racket[max-let-depth] field indicates the
maximum stack depth that @racket[code] creates (not counting the maximum stack depth that @racket[code] creates (not counting the
@ -152,10 +152,10 @@ Wraps a syntax object in a @racket[prefix].}
A supertype for all forms that can appear in compiled code (including A supertype for all forms that can appear in compiled code (including
@racket[expr]s), except for literals that are represented as @racket[expr]s), except for literals that are represented as
themselves and @racket[indirect] structures to create cycles.} themselves.}
@defstruct+[(def-values form) ([ids (listof toplevel?)] @defstruct+[(def-values form) ([ids (listof toplevel?)]
[rhs (or/c expr? seq? indirect? any/c)])]{ [rhs (or/c expr? seq? any/c)])]{
Represents a @racket[define-values] form. Each element of @racket[ids] Represents a @racket[define-values] form. Each element of @racket[ids]
will reference via the prefix either a top-level variable or a local will reference via the prefix either a top-level variable or a local
@ -166,11 +166,11 @@ from before evaluating @racket[rhs].}
@deftogether[( @deftogether[(
@defstruct+[(def-syntaxes form) ([ids (listof symbol?)] @defstruct+[(def-syntaxes form) ([ids (listof symbol?)]
[rhs (or/c expr? seq? indirect? any/c)] [rhs (or/c expr? seq? any/c)]
[prefix prefix?] [prefix prefix?]
[max-let-depth exact-nonnegative-integer?])] [max-let-depth exact-nonnegative-integer?])]
@defstruct+[(def-for-syntax form) ([ids (listof toplevel?)] @defstruct+[(def-for-syntax form) ([ids (listof toplevel?)]
[rhs (or/c expr? seq? indirect? any/c)] [rhs (or/c expr? seq? any/c)]
[prefix prefix?] [prefix prefix?]
[max-let-depth exact-nonnegative-integer?])] [max-let-depth exact-nonnegative-integer?])]
)]{ )]{
@ -192,7 +192,7 @@ Represents a top-level @racket[#%require] form (but not one in a
top-level namespace.} top-level namespace.}
@defstruct+[(seq form) ([forms (listof (or/c form? indirect? any/c))])]{ @defstruct+[(seq form) ([forms (listof (or/c form? any/c))])]{
Represents a @racket[begin] form, either as an expression or at the Represents a @racket[begin] form, either as an expression or at the
top level (though the latter is more commonly a @racket[splice] form). top level (though the latter is more commonly a @racket[splice] form).
@ -203,7 +203,7 @@ After each form in @racket[forms] is evaluated, the stack is restored
to its depth from before evaluating the form.} to its depth from before evaluating the form.}
@defstruct+[(splice form) ([forms (listof (or/c form? indirect? any/c))])]{ @defstruct+[(splice form) ([forms (listof (or/c form? any/c))])]{
Represents a top-level @racket[begin] form where each evaluation is Represents a top-level @racket[begin] form where each evaluation is
wrapped with a continuation prompt. wrapped with a continuation prompt.
@ -221,7 +221,7 @@ to its depth from before evaluating the form.}
(listof provided?)))] (listof provided?)))]
[requires (listof (cons/c (or/c exact-integer? #f) [requires (listof (cons/c (or/c exact-integer? #f)
(listof module-path-index?)))] (listof module-path-index?)))]
[body (listof (or/c form? indirect? any/c))] [body (listof (or/c form? any/c))]
[syntax-body (listof (or/c def-syntaxes? def-for-syntax?))] [syntax-body (listof (or/c def-syntaxes? def-for-syntax?))]
[unexported (list/c (listof symbol?) (listof symbol?) [unexported (list/c (listof symbol?) (listof symbol?)
(listof symbol?))] (listof symbol?))]
@ -282,8 +282,7 @@ Describes an individual provided identifier within a @racket[mod] instance.}
@defstruct+[(expr form) ()]{ @defstruct+[(expr form) ()]{
A supertype for all expression forms that can appear in compiled code, A supertype for all expression forms that can appear in compiled code,
except for literals that are represented as themselves, except for literals that are represented as themselves and some @racket[seq]
@racket[indirect] structures to create cycles, and some @racket[seq]
structures (which can appear as an expression as long as it contains structures (which can appear as an expression as long as it contains
only other things that can be expressions).} only other things that can be expressions).}
@ -296,7 +295,7 @@ only other things that can be expressions).}
[closure-map (vectorof exact-nonnegative-integer?)] [closure-map (vectorof exact-nonnegative-integer?)]
[closure-types (listof (or/c 'val/ref 'flonum))] [closure-types (listof (or/c 'val/ref 'flonum))]
[max-let-depth exact-nonnegative-integer?] [max-let-depth exact-nonnegative-integer?]
[body (or/c expr? seq? indirect? any/c)])]{ [body (or/c expr? seq? any/c)])]{
Represents a @racket[lambda] form. The @racket[name] field is a name Represents a @racket[lambda] form. The @racket[name] field is a name
for debugging purposes. The @racket[num-params] field indicates the for debugging purposes. The @racket[num-params] field indicates the
@ -331,15 +330,8 @@ expression for the closure's body.}
A @racket[lambda] form with an empty closure, which is a procedure A @racket[lambda] form with an empty closure, which is a procedure
constant. The procedure constant can appear multiple times in the constant. The procedure constant can appear multiple times in the
graph of expressions for bytecode, and the @racket[code] field can graph of expressions for bytecode, and the @racket[code] field can
refer back to the same @racket[closure] through an @racket[indirect] be a cycle for a recursive constant procedure; the @racket[gen-id]
for a recursive constant procedure; the @racket[gen-id] is different is different for each such constant.}
for each such constant.}
@defstruct[(indirect zo) ([v closure?]) #:mutable #:prefab]{
An indirection used in expression positions to form cycles.}
@defstruct+[(case-lam expr) ([name (or/c symbol? vector?)] @defstruct+[(case-lam expr) ([name (or/c symbol? vector?)]
[clauses (listof lam?)])]{ [clauses (listof lam?)])]{
@ -349,8 +341,8 @@ Represents a @racket[case-lambda] form as a combination of
arguments given.} arguments given.}
@defstruct+[(let-one expr) ([rhs (or/c expr? seq? indirect? any/c)] @defstruct+[(let-one expr) ([rhs (or/c expr? seq? any/c)]
[body (or/c expr? seq? indirect? any/c)] [body (or/c expr? seq? any/c)]
[flonum? boolean?] [flonum? boolean?]
[unused? boolean?])]{ [unused? boolean?])]{
@ -370,7 +362,7 @@ before evaluating @racket[rhs].}
@defstruct+[(let-void expr) ([count exact-nonnegative-integer?] @defstruct+[(let-void expr) ([count exact-nonnegative-integer?]
[boxes? boolean?] [boxes? boolean?]
[body (or/c expr? seq? indirect? any/c)])]{ [body (or/c expr? seq? any/c)])]{
Pushes @racket[count] uninitialized slots onto the stack and then runs Pushes @racket[count] uninitialized slots onto the stack and then runs
@racket[body]. If @racket[boxes?] is @racket[#t], then the slots are @racket[body]. If @racket[boxes?] is @racket[#t], then the slots are
@ -380,8 +372,8 @@ filled with boxes that contain @|undefined-const|.}
@defstruct+[(install-value expr) ([count exact-nonnegative-integer?] @defstruct+[(install-value expr) ([count exact-nonnegative-integer?]
[pos exact-nonnegative-integer?] [pos exact-nonnegative-integer?]
[boxes? boolean?] [boxes? boolean?]
[rhs (or/c expr? seq? indirect? any/c)] [rhs (or/c expr? seq? any/c)]
[body (or/c expr? seq? indirect? any/c)])]{ [body (or/c expr? seq? any/c)])]{
Runs @racket[rhs] to obtain @racket[count] results, and installs them Runs @racket[rhs] to obtain @racket[count] results, and installs them
into existing slots on the stack in order, skipping the first into existing slots on the stack in order, skipping the first
@ -393,7 +385,7 @@ from before evaluating @racket[rhs].}
@defstruct+[(let-rec expr) ([procs (listof lam?)] @defstruct+[(let-rec expr) ([procs (listof lam?)]
[body (or/c expr? seq? indirect? any/c)])]{ [body (or/c expr? seq? any/c)])]{
Represents a @racket[letrec] form with @racket[lambda] bindings. It Represents a @racket[letrec] form with @racket[lambda] bindings. It
allocates a closure shell for each @racket[lambda] form in allocates a closure shell for each @racket[lambda] form in
@ -407,7 +399,7 @@ then evaluates @racket[body].}
@defstruct+[(boxenv expr) ([pos exact-nonnegative-integer?] @defstruct+[(boxenv expr) ([pos exact-nonnegative-integer?]
[body (or/c expr? seq? indirect? any/c)])]{ [body (or/c expr? seq? any/c)])]{
Skips @racket[pos] elements of the stack, setting the slot afterward Skips @racket[pos] elements of the stack, setting the slot afterward
to a new box containing the slot's old value, and then runs to a new box containing the slot's old value, and then runs
@ -463,8 +455,8 @@ the offset into the array. The @racket[midpt] value is used internally
for lazy calculation of syntax information.} for lazy calculation of syntax information.}
@defstruct+[(application expr) ([rator (or/c expr? seq? indirect? any/c)] @defstruct+[(application expr) ([rator (or/c expr? seq? any/c)]
[rands (listof (or/c expr? seq? indirect? any/c))])]{ [rands (listof (or/c expr? seq? any/c))])]{
Represents a function call. The @racket[rator] field is the expression Represents a function call. The @racket[rator] field is the expression
for the function, and @racket[rands] are the argument for the function, and @racket[rands] are the argument
@ -473,9 +465,9 @@ expressions. Before any of the expressions are evaluated,
used as temporary space).} used as temporary space).}
@defstruct+[(branch expr) ([test (or/c expr? seq? indirect? any/c)] @defstruct+[(branch expr) ([test (or/c expr? seq? any/c)]
[then (or/c expr? seq? indirect? any/c)] [then (or/c expr? seq? any/c)]
[else (or/c expr? seq? indirect? any/c)])]{ [else (or/c expr? seq? any/c)])]{
Represents an @racket[if] form. Represents an @racket[if] form.
@ -483,9 +475,9 @@ After @racket[test] is evaluated, the stack is restored to its depth
from before evaluating @racket[test].} from before evaluating @racket[test].}
@defstruct+[(with-cont-mark expr) ([key (or/c expr? seq? indirect? any/c)] @defstruct+[(with-cont-mark expr) ([key (or/c expr? seq? any/c)]
[val (or/c expr? seq? indirect? any/c)] [val (or/c expr? seq? any/c)]
[body (or/c expr? seq? indirect? any/c)])]{ [body (or/c expr? seq? any/c)])]{
Represents a @racket[with-continuation-mark] expression. Represents a @racket[with-continuation-mark] expression.
@ -493,7 +485,7 @@ After each of @racket[key] and @racket[val] is evaluated, the stack is
restored to its depth from before evaluating @racket[key] or restored to its depth from before evaluating @racket[key] or
@racket[val].} @racket[val].}
@defstruct+[(beg0 expr) ([seq (listof (or/c expr? seq? indirect? any/c))])]{ @defstruct+[(beg0 expr) ([seq (listof (or/c expr? seq? any/c))])]{
Represents a @racket[begin0] expression. Represents a @racket[begin0] expression.
@ -507,7 +499,7 @@ Represents a @racket[#%variable-reference] form.}
@defstruct+[(assign expr) ([id toplevel?] @defstruct+[(assign expr) ([id toplevel?]
[rhs (or/c expr? seq? indirect? any/c)] [rhs (or/c expr? seq? any/c)]
[undef-ok? boolean?])]{ [undef-ok? boolean?])]{
Represents a @racket[set!] expression that assigns to a top-level or Represents a @racket[set!] expression that assigns to a top-level or
@ -518,8 +510,8 @@ After @racket[rhs] is evaluated, the stack is restored to its depth
from before evaluating @racket[rhs].} from before evaluating @racket[rhs].}
@defstruct+[(apply-values expr) ([proc (or/c expr? seq? indirect? any/c)] @defstruct+[(apply-values expr) ([proc (or/c expr? seq? any/c)]
[args-expr (or/c expr? seq? indirect? any/c)])]{ [args-expr (or/c expr? seq? any/c)])]{
Represents @racket[(call-with-values (lambda () args-expr) proc)], Represents @racket[(call-with-values (lambda () args-expr) proc)],
which is handled specially by the run-time system.} which is handled specially by the run-time system.}

2
collects/tests/compiler/zo-test-worker.rkt
View File

@ -232,7 +232,7 @@
[parse-marshalled [parse-marshalled
#t #t
(zo-parse/bytes marshal-parsed)] (zo-parse/bytes marshal-parsed)]
[compare-parsed-to-parsed-marshalled #;[compare-parsed-to-parsed-marshalled
#f #f
(equal?/why-not parse-orig parse-marshalled)] (equal?/why-not parse-orig parse-marshalled)]
#;[marshal-marshalled #;[marshal-marshalled