Abstract

Interpreters and compilers are two different ways of implementing

programming languages. An interpreter directly executes its program

input. It is a concise definition of the semantics of a programming

language and is easily implemented. A compiler translates its program

input into another language. It is more difficult to construct, but

the code that it generates runs faster than interpreted code.

In this dissertation, we propose a transformation-based foundation for

deriving compilers from semantic specifications in the form of four

rules. These rules give apriori advice for staging, and allow

explicit compiler derivation that would be less succinct with partial

evaluation. When applied, these rules turn an interpreter that

directly executes its program input into a compiler that emits the

code that the interpreter would have executed.

We formalize the language syntax and semantics to be used for the

interpreter and the compiler, and also specify a notion of equality.

It is then possible to precisely state the transformation rules and to

prove both local and global correctness theorems. And although the

transformation rules were developed so as to apply to an interpreter

written in a denotational style, we consider how to modify

non-denotational interpreters so that the rules apply. Finally, we

illustrate these ideas by considering a larger example: a Prolog

implementation.

Library of Congress Subject Headings

Programming languages (Electronic computers); Code generators; Interpreters (Computer programs); Compilers (Computer programs)

Publication Date

12-2014

Document Type

Dissertation

Student Type

Graduate

Degree Name

Computing and Information Sciences (Ph.D.)

Advisor

Matthew Fluet

Advisor/Committee Member

James Heliotis

Advisor/Committee Member

William McKeeman

Comments

Physical copy available from RIT's Wallace Library at QA76.7 .N86 2014

Campus

RIT – Main Campus

Plan Codes

COMPIS-PHD

Download

Share

COinS