An experiment in partial evaluation: the generation of a compiler generator

  title={An experiment in partial evaluation: the generation of a compiler generator},
  author={Neil D. Jones and Peter Sestoft and Harald S{\o}ndergaard},
The present paper is an extended abstract of (Jones 1985), in which a running , non-trivial partial evaluator is described . As far as we know, this partia l evaluator is the first which has been used in practice to transform interpreters into corresponding stand-alone compilers, or to generate a compile r generator by transforming itself . A partial evaluator is a program (call it mix) written in a programmin g language L, which takes as input a program p and a known value d l of p' s first… 

Partial Evaluation and the Generation of Program Generators

Partial evaluation is a program optimization technique closely related to but different from Jorring and Scherlis’ staging transformations, and emphasizes, in comparison with [11,27] and other program transformation work, full automation and the generation of program generators as well as transforming single programs.

Generating action compilers by partial evaluation

Even though the compiler produces Scheme code, the code runs as fast as that produced by the previous action compilers.

Generating a compiler for a lazy language by partial evaluation

The paper describes the most important techniques used, especially the binding time improvements needed in order to get small and efficient target programs, and the performance of the compiler is compared with two compilers for similar languages: Miranda and LML.

A compiler generator produced by a self-applicable specializer can have a surprisingly natural and u

This paper describes the structure of, and the ideas behind, a self-applicable specializer of programs, as well as the principles of operation of a compiler generator that has been produced

A self-applicable partial evaluator and its use in incremental compilation

This paper presents an experimental implementation of a self-applicable partial evaluator in Prolog used for compiler generation and compiler generator generation. The partial evaluator is an

An introduction to partial evaluation

Partial evaluation provides a unifying paradigm for a broad spectrum of work in program optimization compiling interpretation and the generation of automatic program generators and has important applications to scientific computing, logic programming, metaprogramming, and expert systems.

Generating a Pattern Matching Compiler by Partial Evaluation

Partial evaluation can be used for automatic generation of compilers and was first implemented by Jones et. al. [9]. Since partial evaluation was extended to higher order functional languages, Jones

A Self-Applicable Partial Evaluator for the Logic Programming Language Gödel ( Extended Abstract )

SAGE is described, a self-applicable partial evaluator for meta-programs in the logic programming language Gödel and can be used to generate a compiler-generator.

Partial Evaluation, Self-Application and Types

Questions of computational complexity and the desirability of a theoretical framework for studying complexity in partial evaluation are discussed and some first steps toward the problem of verifying type correctness in interpreters, compilers and partial evaluators are outlined.

Mathematical equations as executable models of mechanical systems

Focusing on mechanical systems as an important class of physical systems, this work study the form of analytical models that arise in this domain, along with the process by which domain experts map them to executable codes, and shows the key steps needed to automate this mapping.



Control Flow Treatment in a Simple Semantics-Directed Compiler Generator

A simple algebra-based algorithm for compiler generation is described which maps each source program into a sequence of compile-time actions whose net effect on execution is the production of a semantically equivalent target program.

Partial evaluation as a means for inferencing data structures in an applicative language: a theory and implementation in the case of prolog

Transformations which account for pruning, forward data structure propagation and opening are formally introduced and proved to preserve meaning of programs and are related to research in rule-based systems and logic.

On compiling embedded languages in LISP

This paper has implemented the iterative statement and a CLISP-like pattern matcher and used a program manipulation system to generate object programs in LISP.

A semantics-directed compiler generator

This paper introduces a formal notition, the semanfic grammar, for defining programming languages, which handles both static and dynamic semantics, both compile and run-time actions.

Experiments with a supercompiler

This paper presents and discusses some examples of the operation of the first experimental model of a supercompiler, and highlights most important features of the supercompilers and intimate its potential uses.

A Transformation System for Developing Recursive Programs

A system of rules for transforming programs is described, with the programs in the form of recursion equations. An initially very simple, lucid, and hopefully correct program is transformed into a

Parital Computation of Programs

  • Y. Futamura
  • Computer Science
    RIMS Symposium on Software Science and Engineering
  • 1982
The formal theory of partial computation, technical problems in making it practical, and its future research problems are discussed.

Theory of Recursive Functions and Effective Computability

Central concerns of the book are related theories of recursively enumerable sets, of degree of un-solvability and turing degrees in particular and generalizations of recursion theory.