Compilers: principles, techniques, and tools
Compilers: principles, techniques, and tools
SIGPLAN '86 Proceedings of the 1986 SIGPLAN symposium on Compiler construction
ORBIT: an optimizing compiler for scheme
SIGPLAN '86 Proceedings of the 1986 SIGPLAN symposium on Compiler construction
&lgr;-V-CS: an extended &lgr;-calculus for scheme
LFP '88 Proceedings of the 1988 ACM conference on LISP and functional programming
Realistic compilation by program transformation (detailed summary)
POPL '89 Proceedings of the 16th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Control-flow analysis of higher-order languages of taming lambda
Control-flow analysis of higher-order languages of taming lambda
Compiling with continuations
The revised report on the syntactic theories of sequential control and state
Theoretical Computer Science
Improving binding times without explicit CPS-conversion
LFP '92 Proceedings of the 1992 ACM conference on LISP and functional programming
Reasoning about programs in continuation-passing style.
LFP '92 Proceedings of the 1992 ACM conference on LISP and functional programming
ESOP'92 Symposium proceedings on 4th European symposium on programming
Is continuation-passing useful for data flow analysis?
PLDI '94 Proceedings of the ACM SIGPLAN 1994 conference on Programming language design and implementation
Reasoning about programs in continuation-passing style
Lisp and Symbolic Computation - Special issue on continuations—part I
A correspondence between continuation passing style and static single assignment form
IR '95 Papers from the 1995 ACM SIGPLAN workshop on Intermediate representations
TIL: a type-directed optimizing compiler for ML
PLDI '96 Proceedings of the ACM SIGPLAN 1996 conference on Programming language design and implementation
Lambda-splitting: a higher-order approach to cross-module optimizations
ICFP '97 Proceedings of the second ACM SIGPLAN international conference on Functional programming
ACM SIGPLAN Notices
Contification using dominators
Proceedings of the sixth ACM SIGPLAN international conference on Functional programming
Correctness of Procedure Representations in Higher-Order Assembly Language
Proceedings of the 7th International Conference on Mathematical Foundations of Programming Semantics
The scheme 311 compiler an exercise in denotational semantics
LFP '84 Proceedings of the 1984 ACM Symposium on LISP and functional programming
Proceedings of ACM conference on Proving assertions about programs
Rabbit: A Compiler for Scheme
A computational formalization for partial evaluation
Mathematical Structures in Computer Science
Building up to macroprogramming: an intermediate language for sensor networks
IPSN '05 Proceedings of the 4th international symposium on Information processing in sensor networks
Automatically RESTful web applications: marking modular serializable continuations
Proceedings of the 14th ACM SIGPLAN international conference on Functional programming
The two-state solution: native and serializable continuations accord
Proceedings of the ACM international conference on Object oriented programming systems languages and applications
| Hi-index | 0.00 |
In order to simplify the compilation process, many compilers for higher-order languages use the continuation-passing style (CPS) transformation in a first phase to generate an intermediate representation of the source program. The salient aspect of this intermediate form is that all procedures take an argument that represents the rest of the computation (the "continuation"). Since the naïve CPS transformation considerably increases the size of programs, CPS compilers perform reductions to produce a more compact intermediate representation. Although often implemented as a part of the CPS transformation, this step is conceptually a second phase. Finally, code generators for typical CPS compilers treat continuations specially in order to optimize the interpretation of continuation parameters.A thorough analysis of the abstract machine for CPS terms shows that the actions of the code generator invert the naïve CPS translation step. Put differently, the combined effect of the three phases is equivalent to a source-to-source transformation that simulates the compaction phase. Thus, fully developed CPS compilers do not need to employ the CPS transformation but can achieve the same results with a simple source-level transformation.