Download presentation
Presentation is loading. Please wait.
1
Continuation Marks A john clements talk
2
What are Continuation Marks?
3
What are Continuation Marks?
What are Continuations?
4
What are Continuation Marks?
What are Continuations? Continuations Paren-hackers Contexts Stacks Compiler-writers Semanticists
5
Contexts Stacks Compiler-writers Semanticists (let*-2vals
([kept-vars (cond [(eq? tail-bound 'all) free-vars] [else (filter (lambda (varref) (ormap (lambda (binding) (bound-identifier=? binding varref)) tail-bound)) free-vars)])] [var-clauses (map (lambda (x) (list x (d->so `(quote-syntax ,x)))) kept-vars)] [let-bindings (filter (lambda (var) (case (syntax-property var 'stepper-binding-type) ((let-bound) #t) ((lambda-bound stepper-temp top-level) #f) (else (error 'make-debug-info "varref ~a's binding-type info \ was not recognized: ~a" (syntax-e var) (syntax-property var 'stepper-binding-type))))) [lifter-syms (map get-lifted-var let-bindings)] [quoted-lifter-syms (map (lambda (b) (d->so `(quote-syntax ,b))) lifter-syms)] [let-clauses (map list lifter-syms quoted-lifter-syms)]) (make-full-mark source label (append var-clauses (if lifting? let-clauses null))))
6
Contexts Stacks Compiler-writers Semanticists mark mark mark
(let*-2vals ([kept-vars (cond [(eq? tail-bound 'all) free-vars] [else (filter (lambda (varref) (ormap (lambda (binding) (bound-identifier=? binding varref)) tail-bound)) free-vars)])] [var-clauses (map (lambda (x) (list x (d->so `(quote-syntax ,x)))) kept-vars)] [let-bindings (filter (lambda (var) (case (syntax-property var 'stepper-binding-type) ((let-bound) #t) ((lambda-bound stepper-temp top-level) #f) (else (error 'make-debug-info "varref ~a's binding-type info \ was not recognized: ~a" (syntax-e var) (syntax-property var 'stepper-binding-type))))) [lifter-syms (map get-lifted-var let-bindings)] [quoted-lifter-syms (map (lambda (b) (d->so `(quote-syntax ,b))) lifter-syms)] [let-clauses (map list lifter-syms quoted-lifter-syms)]) (make-full-mark source label (append var-clauses (if lifting? let-clauses null)))) mark mark mark
7
Closing the Loop Programming Language Marks
8
Closing the Loop Programming Language with marks
9
Closing the Loop oops! Programming Language with marks
10
Closing the Loop Programming Language with marks
11
Contexts Stacks Compiler-writers Semanticists mark mark mark
(let*-2vals ([kept-vars (cond [(eq? tail-bound 'all) free-vars] [else (filter (lambda (varref) (ormap (lambda (binding) (bound-identifier=? binding varref)) tail-bound)) free-vars)])] [var-clauses (map (lambda (x) (list x (d->so `(quote-syntax ,x)))) kept-vars)] [let-bindings (filter (lambda (var) (case (syntax-property var 'stepper-binding-type) ((let-bound) #t) ((lambda-bound stepper-temp top-level) #f) (else (error 'make-debug-info "varref ~a's binding-type info \ was not recognized: ~a" (syntax-e var) (syntax-property var 'stepper-binding-type))))) [lifter-syms (map get-lifted-var let-bindings)] [quoted-lifter-syms (map (lambda (b) (d->so `(quote-syntax ,b))) lifter-syms)] [let-clauses (map list lifter-syms quoted-lifter-syms)]) (make-full-mark source label (append var-clauses (if lifting? let-clauses null)))) mark mark mark
12
Contexts Stacks Compiler-writers Semanticists (let*-2vals
([kept-vars (cond [(eq? tail-bound 'all) free-vars] [else (filter (lambda (varref) (ormap (lambda (binding) (bound-identifier=? binding varref)) tail-bound)) free-vars)])] [var-clauses (map (lambda (x) (list x (d->so `(quote-syntax ,x)))) kept-vars)] [let-bindings (filter (lambda (var) (case (syntax-property var 'stepper-binding-type) ((let-bound) #t) ((lambda-bound stepper-temp top-level) #f) (else (error 'make-debug-info "varref ~a's binding-type info \ was not recognized: ~a" (syntax-e var) (syntax-property var 'stepper-binding-type))))) [lifter-syms (map get-lifted-var let-bindings)] [quoted-lifter-syms (map (lambda (b) (d->so `(quote-syntax ,b))) lifter-syms)] [let-clauses (map list lifter-syms quoted-lifter-syms)]) (make-full-mark source label (append var-clauses (if lifting? let-clauses null))))
13
New Language Forms
14
New Language Forms Introducing marks: Observing marks:
(with-continuation-mark M M) mark value body (current-continuation-marks)
15
New Language Forms Synopsis of Reduction Semantics: New Contexts:
E = [] | (E M) | (V E) | … | (w-c-m V E) * *With restrictions on successive w-c-m’s New Reductions: E[(w-c-m V V)] -> E[V] E[(w-c-m V (w-c-m M M))] -> E[(w-c-m M M)] E[(c-c-m)] -> E[X(E)]
16
New Language Forms (define (loop x) (w-c-m x (loop (+ x 1))))
(w-c-m 0 (loop (+ 0 1))) -> (w-c-m 0 (loop 1)) -> (w-c-m 0 (w-c-m 1 (loop (+ 1 1)))) -> (w-c-m 1 (loop (+ 1 1))) -> (w-c-m 1 (loop 2)) -> (w-c-m 1 (w-c-m 2 (loop (+ 2 1)))) -> ...
17
New Language Forms (define (f x) (w-c-m x (+ (f x) 1))) (loop 0) ->
(w-c-m 0 (+ (f 0) 1)) -> (w-c-m 0 (+ (w-c-m 0 (+ (f 0) 1)) 1)) -> (w-c-m 0 (+ (w-c-m 0 (+ (w-c-m 0 (+ (f 0) 1)) 1)) 1)) -> (w-c-m 0 (+ (w-c-m 0 (+ (w-c-m 0 (+ (w-c-m 0 (+ (f 0) 1)) 1)) 1)) 1)) -> ...
18
Expressiveness Conjecture: cannot be expressed in a “tail-call preserving way” by state, continuations, etc. Difficult to state claim clearly
19
Using Continuation Marks
(to build a stepper)
20
(using continuation marks)
Building a Stepper (using continuation marks)
21
Building a Stepper Why a Stepper? How to build a stepper?
A stepper is a sound debugger A stepper is a complete debugger … with a suitable proof How to build a stepper? Annotation with continuation marks Non-invasive (well-defined) implementation
22
Building a Stepper Annotation: Marks must contain: Breakpoints
Source position Values of free variables Breakpoints Where? Everywhere. No, even more than that.
23
Building a Stepper Pragmatics
24
Pragmatics Orthogonality of annotations Add a ‘key’ to each mark:
Marks with different keys are orthogonal (with-continuation-mark M M M) key mark body (current-continuation-marks M)
25
Macro Reversal (cond [a b] [c d]) ?? R? R (if c d (error)) (if a b
26
“Needed” variables Variables stored in each mark Avoid duplication
Store all variables which are not guaranteed to occur in an enclosing mark.
27
“Needed” variables Variable “a” is not needed in these contexts
(letrec ([a 13] [b (+ a 14)] [c (lambda () a)]) (g a) Variable “a” is needed in these contexts
28
Opaque Values Closures: procedures, classes Structures, Units
Put them in a table
29
Before & After Steps (+ 1 (if true 3 4)) -> (+ 1 3)
Requires additional breakpoints for: • tail-position expressions • results of primitive applications
30
Unannotated Code Libraries Partial Annotation
Complete Reconstruction not possible Detection necessary
31
Lifting & Renaming Newly created closures go to top level
Names must be assigned at runtime Extra binding created
32
Lightweight Inspection
(what else can we do with continuation marks?)
33
Stack Inspection Widely used security measure
Associate privileges with ‘principals’ Inspect the stack to make guarantees about execution Implemented in a variety of ways: Stack Inspection “Security-passing style” ...
34
Stack Inspection … or using continuation marks
Preserves tail-call optimization Place marks on the “bad” code T T G G OLD NEW
35
Aspect-Oriented Programming
Allows textual separation of program aspects. May be implemented by a static annotation … with certain run-time decisions “cflow” rules in AspectJ But what about tail-call optimization? May be recovered with continuation marks
36
Lightweight Inspection
Other uses waiting to be found…
37
Lightweight Inspection
Other uses waiting to be found… Tell me yours!
Similar presentations
© 2025 SlidePlayer.com. Inc.
All rights reserved.