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

renaming variables for clarity

Browse Source
This commit is contained in:
Danny Yoo 2012-03-01 21:52:27 -05:00
parent 1cd5e9b7cc
commit b788e1bb57
2 changed files with 24 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
compiler/compiler.rkt
View File

@ -1045,9 +1045,9 @@
(length (App-operands exp)))) (length (App-operands exp))))
(define proc+operands-code (define proc+operands-code
(cond (cond
;; Optimization: if the operand and operands are all simple, we don't need to ;; Optimization: if the operand and operands are all side-effect-free, we don't need to
;; juggle. ;; juggle.
[(andmap simple-expression? (cons (App-operator exp) (App-operands exp))) [(andmap side-effect-free-expression? (cons (App-operator exp) (App-operands exp)))
(define proc-code (compile (App-operator exp) extended-cenv 'proc next-linkage/expects-single)) (define proc-code (compile (App-operator exp) extended-cenv 'proc next-linkage/expects-single))
(define operand-codes (map (lambda: ([operand : Expression] (define operand-codes (map (lambda: ([operand : Expression]
[target : Target]) [target : Target])
@ -1224,8 +1224,8 @@
[else [else
(cond (cond
;; If all the arguments are primitive enough (all constants, localrefs, or toplevelrefs), ;; If all the arguments are primitive enough (all constants, localrefs, or toplevelrefs),
;; then application requires no stack space at all, and application is especially simple. ;; then application requires no stack space at all, and application is especially side-effect-free.
[(andmap simple-expression? (App-operands exp)) [(andmap side-effect-free-expression? (App-operands exp))
(let* ([operand-knowledge (let* ([operand-knowledge
(map (lambda: ([arg : Expression]) (map (lambda: ([arg : Expression])
(extract-static-knowledge (extract-static-knowledge
@ -1242,8 +1242,8 @@
operand-knowledge)] operand-knowledge)]
[operand-poss [operand-poss
(simple-operands->opargs (map (lambda: ([op : Expression]) (side-effect-free-operands->opargs (map (lambda: ([op : Expression])
(ensure-simple-expression (ensure-side-effect-free-expression
(adjust-expression-depth op n n))) (adjust-expression-depth op n n)))
(App-operands exp)) (App-operands exp))
operand-knowledge)]) operand-knowledge)])
@ -1272,7 +1272,7 @@
(length rest-operands)) (length rest-operands))
(map (lambda: ([constant-operand : Expression]) (map (lambda: ([constant-operand : Expression])
(ensure-simple-expression (ensure-side-effect-free-expression
(adjust-expression-depth constant-operand (adjust-expression-depth constant-operand
(length constant-operands) (length constant-operands)
n))) n)))
@ -1309,7 +1309,7 @@
(make-Const 0))] (make-Const 0))]
[(constant-operand-poss) [(constant-operand-poss)
(simple-operands->opargs constant-operands constant-operand-knowledge)] (side-effect-free-operands->opargs constant-operands constant-operand-knowledge)]
[(rest-operand-poss) [(rest-operand-poss)
(build-list (length rest-operands) (build-list (length rest-operands)
@ -1343,33 +1343,33 @@
(: ensure-simple-expression (Expression -> (U Constant ToplevelRef LocalRef PrimitiveKernelValue))) (: ensure-side-effect-free-expression (Expression -> (U Constant ToplevelRef LocalRef PrimitiveKernelValue)))
(define (ensure-simple-expression e) (define (ensure-side-effect-free-expression e)
(if (or (Constant? e) (if (or (Constant? e)
(LocalRef? e) (LocalRef? e)
(ToplevelRef? e) (ToplevelRef? e)
(PrimitiveKernelValue? e)) (PrimitiveKernelValue? e))
e e
(error 'ensure-simple-expression))) (error 'ensure-side-effect-free-expression)))
(: simple-expression? (Expression -> Boolean)) (: side-effect-free-expression? (Expression -> Boolean))
;; Produces true if the expression is simple and constant. ;; Produces true if the expression is side-effect-free and constant.
;; TODO: generalize this so that it checks that the expression is ;; TODO: generalize this so that it checks that the expression is
;; side-effect free. If it's side-effect free, then we can compute ;; side-effect free. If it's side-effect free, then we can compute
;; the expressions in any order. ;; the expressions in any order.
(define (simple-expression? e) (define (side-effect-free-expression? e)
(or (Constant? e) (or (Constant? e)
(LocalRef? e) (LocalRef? e)
(ToplevelRef? e) (ToplevelRef? e)
(PrimitiveKernelValue? e))) (PrimitiveKernelValue? e)))
(: simple-operands->opargs ((Listof (U Constant LocalRef ToplevelRef PrimitiveKernelValue)) (: side-effect-free-operands->opargs ((Listof (U Constant LocalRef ToplevelRef PrimitiveKernelValue))
(Listof CompileTimeEnvironmentEntry) (Listof CompileTimeEnvironmentEntry)
-> (Listof OpArg))) -> (Listof OpArg)))
;; Produces a list of OpArgs if all the operands are particularly simple. ;; Produces a list of OpArgs if all the operands are particularly side-effect-free.
(define (simple-operands->opargs rands knowledge) (define (side-effect-free-operands->opargs rands knowledge)
(map (lambda: ([e : (U Constant LocalRef ToplevelRef PrimitiveKernelValue)] (map (lambda: ([e : (U Constant LocalRef ToplevelRef PrimitiveKernelValue)]
[k : CompileTimeEnvironmentEntry]) [k : CompileTimeEnvironmentEntry])
(cond (cond
@ -1423,22 +1423,21 @@
(: split-operands-by-constants (: split-operands-by-constants
((Listof Expression) -> ((Listof Expression) ->
(values (Listof (U Constant LocalRef ToplevelRef)) (values (Listof (U Constant))
(Listof Expression)))) (Listof Expression))))
;; Splits off the list of operations into two: a prefix of constant ;; Splits off the list of operations into two: a prefix of
;; or simple expressions, and the remainder. ;; constant expressions, and the remainder. TODO: if we can
;; TODO: if we can statically determine what arguments are immutable, regardless of ;; statically determine what arguments are immutable, regardless of
;; side effects, we can do a much better job here... ;; side effects, we can do a much better job here...
(define (split-operands-by-constants rands) (define (split-operands-by-constants rands)
(let: loop : (values (Listof (U Constant LocalRef ToplevelRef)) (Listof Expression)) (let: loop : (values (Listof (U Constant)) (Listof Expression))
([rands : (Listof Expression) rands] ([rands : (Listof Expression) rands]
[constants : (Listof (U Constant LocalRef ToplevelRef)) [constants : (Listof (U Constant))
empty]) empty])
(cond [(empty? rands) (cond [(empty? rands)
(values (reverse constants) empty)] (values (reverse constants) empty)]
[else (let ([e (first rands)]) [else (let ([e (first rands)])
(if (or (Constant? e) (if (or (Constant? e)
;; These two are commented out because it's not sound otherwise. ;; These two are commented out because it's not sound otherwise.
#;(and (LocalRef? e) (not (LocalRef-unbox? e))) #;(and (LocalRef? e) (not (LocalRef-unbox? e)))
#;(and (ToplevelRef? e) #;(and (ToplevelRef? e)

2
version.rkt
View File

@ -7,4 +7,4 @@
(provide version) (provide version)
(: version String) (: version String)
(define version "1.208") (define version "1.213")