Abstract Syntax Tree Research Articles

Generation of formatters for context-free languages

Good documentation is important for the production of reusable and maintainable software. For the production of accurate documentation it is necessary that the original program text is not copied manually to obtain a typeset version. Apart from being tedious, this will invariably introduce errors. The production of tools that support the production of legible and accurate documentation is a software engineering challenge in itself. We present an algebraic approach to the generation of tools that produce typographically effective presentations of computer programs. A specification of a formatter is generated from the context-free grammar of a (programming) language. These generated formatters translate abstract syntax trees of programs into box expressions. Box expressions are translated by language-independent interpreters of the box language into ASCII or T E X. The formatting rules that are generated can easily be tuned in order to get the desired formatting of programs. We demonstrate this by means of real-life applications. Furthermore, we give a practical solution for the problem of formatting comments, which occur in the original text. The formatter generation approach proposed in this article can be used to generate formatting programs for arbitrary programming environments. Our formatter generation approach can be used to automatically generate formatters that have to be programmed explicitly in other systems.

Decompilation: the enumeration of types and grammars

While a compiler produces low-level object code from high-level source code, a decompiler produces high-level code from low-level code and has applications in the testing and validation of safety-critical software. The decompilation of an object code provides an independent demonstration of correctness that is hard to better for industrial purposes (an alternative is to prove the compiler correct). But, although compiler compilers are in common use in the software industry, a decompiler compiler is much more unusual. It turns out that a data type specification for a programming-language grammar can be remolded into a functional program that enumerates all of the abstract syntax trees of the grammar. This observation is the springboard for a general method for compiling decompilers from the specifications of (nonoptimizing) compilers. This paper deals with methods and theory, together with an application of the technique. The correctness of a decompiler generated from a simple occam-like compiler specification is demonstrated. The basic problem of enumerating the syntax trees of grammars, and then stopping, is shown to have no recursive solution, but methods of abstract interpretation can be used to guarantee the adequacy and completeness of our technique in practical instances, including the decompiler for the language presented here.

Array morphology

Array morphology is the study of the form, structure, and evolution of arrays. An array annotation for a program written in an applicative array language is an abstract syntax tree for the program, amended with information about the arrays created by that program. Array notations are useful in the production of efficient compiled code for applicative array programs. Array morphology is shown to be an effective compiler writer's tool. Examples of an array annotator in action are presented, showing its value in array morphology. Array morphology is shown to provide methods for static detection of certain classes of programming errors. Assertions are a generalization of declarations that offer significant benefits to application writers as well as compiler writers. Although assertions are executable code, they can often be evaluated at compilation time. Assertions, and therefore declarations, may be represented as conjunctions, and are, therefore, conforming extensions to ISO Standard APL. A domain conjunction is offered as an example of how assertions might be defined in APL or J.

Production trees: a compact representation of parsed programs

Abstract syntax trees were devised as a compact alternative to parse trees, because parse trees are known to require excessive amounts of storage to represent parsed programs. However, the savings that abstract syntax trees actually achieve have never been precisely described because the necessary analysis has been missing. Without it, one can only measure particular cases that may not adequately represent all the possible behaviors. We introduce a data structure, production trees, that are more compact than either abstract syntax trees or parse trees. Further, we develop the necessary analysis to characterize the storage requirements of parse trees, abstract syntax trees, and production trees and relate the size of all three to the size of the program's text. The analysis yields the parameters needed to characterize these storage behaviors over their entire range. We flesh out the analysis by measuring these parameters for a sample of “C” programs. For these programs, production trees were from 1/15 to 1/23 the size of the corresponding parse tree, l/2.7 the size of a (minimal) abstract syntax tree, and averaged only 2.83 times the size of the program text.

Facilitating process prototyping by controlling the impact of change

Facilitating process prototyping by controlling the impact of change

Structured Editor Support for Modularity and Data Abstraction

Language facilities for data abstraction and modularity have traditionally involved extensions to the declaratory syntax of the languages. Batch compiler technology forces the separation of the editing of this syntax from its being checked by the compiler, making programming more difficult. We discuss an alternate method of supporting such features in a language-based structured editor. Rather than adding syntax to the language, we simply use the editor to restrict uses of names. In order to specify the restrictions, we provide a language-independent notion of names and scopes in our abstract syntax tree.

An algorithm for generating abstract syntax trees

In this paper, we discuss the notion of an abstract syntax. An algorithm is presented for automatically deriving an abstract syntax directly from a BNF grammar. The implementation of this algorithm and its application to the grammar for Modula are discussed.