Attribute grammars are a formalism for specifying programming languages. They have been applied to a great number of systems automatically producing language implementations from their specifications. The systems and their specification languages can be evaluated and classified according to their level of application support, linguistic characteristics, and degree of automation.A survey of attribute grammar-based specification languages is given. The modern advanced specification languages extend the core attribute grammar model with concepts and primitives from established programming paradigms. The main ideas behind the developed attribute grammar paradigms are discussed, and representative specification languages are presented with a common example grammar. The presentation is founded on mapping elements of attribute grammars to their counterparts in programming languages. This methodology of integrating two problem-solving disciplines together is explored with a classification of the paradigms into structured, modular, object-oriented, logic, and functional attribute grammars. The taxonomy is complemented by introducing approaches based on an implicit parallel or incremental attribute evaluation paradigm.

Attribute grammar paradigms—a high-level methodology in language implementation

In this paper, attribute grammars are viewed as specifying translations from source language terms into target language terms. The terms are constructed over a hierarchical signature consisting of a semantic and a syntactic part. Attribute grammars are redefined to become morphisms in the category of such signatures, called attribute coupled grammars, such that they come with an associative composition operation. The composition allows for a new kind of modularity in compiler specifications. The paper also discusses properties of the concept with respect to attribute evaluation and application as a tree transformation device.

Attribute coupled grammars

The recognition of standard computational structures (cliches) in a program can help an experienced programmer understand the program. Based on the known relationships between the cliches, a hierarchical description of the program's design can be recovered. We develop and study a graph parsing approach to automating program recognition in which programs are represented as attributed dataflow graphs and a library of cliches is encoded as an attributed graph grammar. Graph parsing is used to recognize cliches in the code.
We demonstrate that this graph parsing approach is a feasible and useful way to automate program recognition. In studying this approach, we have experimented with two medium-sized, real-world simulator programs. There are three aspects of our study.
First, we evaluate our representation's ability to suppress many common forms of program variation which hinder recognition. We find that our recognition approach is robust under syntactic, organizational, and implementational variation, as well as variation due to delocalization, unfamiliar code, and some function-sharing optimizations.
Second, we investigate the expressiveness of our graph formalism for capturing programming cliches. The formalism is able to concisely encode algorithmic and data aggregation cliches.
Third, we empirically and analytically study the computational cost of our recognition approach with respect to the real-world simulator programs. We find that although our graph parsing algorithm is exponential in the worst case, its complexity is reduced in its practical application to program recognition. (Copies available exclusively from MIT Libraries, Rm. 14-0551, Cambridge, MA 02139-4307. Ph. 617-253-5668; Fax 617-253-1690.)

Automated program recognition by graph parsing

Automated program recognition: a feasibility demonstration

We have designed and implemented an interprocedural program analyzer generator, called system Z. Our goal is to automate the generation and management of semantics-based interprocedural program analysis for a wide range of target languages.System Z is based on the abstract interpretation framework. The input to system Z is a high-level specification of an abstract interpreter. The output is a C code for the specified interprocedural program analyzer. The system provides a high-level command set (called projection expressions) in which the user can tune the analysis in accuracy and cost. The user writes projection expressions for selected domains; system Z takes care of the remaining things so that the generated analyzer conducts an analysis over the projected domains, which will vary in cost and accuracy according to the projections.We demonstrate the system's capabilities by experiments with a set of generated analyzers which can analyze C, FORTRAN, and SCHEME programs.

/pdf/automatic-generation-and-management-of-interprocedural-5ebj9jmh0q.pdf

Automatic generation and management of interprocedural program analyses

The adequacy of attribute grammars as a compiler writing tool is studied on the basis of the experiences on attribute grammars for Pascal and a subset of Euclid. A qualitative assessment of the grammars shows that the compiler oriented view in the design of an attribute grammar tends to make the grammar hard to understand. A design discipline is proposed to improve the comprehensibility of the grammar. Quantitative measurements of the automatically generated compilers suggest that an efficient compiler can be produced from an attribute grammar. To achieve this, a carefully optimized implementation of the compiler-compiler is required.

Compiler construction using attribute grammars

Language processor generators are systems that produce various language processors (including compilers) on the basis of a high-level specification. The design of language processor generators is discussed on the basis of experiments with a traditional compiler writing system (HLP78) employing pore LALR parsing and general attribute grammars. It is argued that these methods are too primitive from the practical point of view. The design of a new language processor generator, HLP84, is based on this view. This system is an attempt to provide high-level tools for a restricted class of applications (one-pass analysis). The syntactic facilities include regular expressions on the right-hand sides of productions, a disambiguating mechanism that is integrated with regular expressions, and a mechanism for using semantic information to aid parsing. The semantic facilities include automatic support for semantic error handling and for symbol tables. Early experiences with the new system show that in spite of the general overhead caused by the higher automation level, the system allows the generation of reasonably efficient processors.

The design of a language processor generator

A new language is introduced for the specification of semantic analysis of programming languages. The language is based on the concept of one-pass attribute grammars. Various extensions of this basic formalism are incorporated in the language, including disciplined global variables, facilities for symbol processing, and features supporting semantic error detection and recovery. To encourage the writing of declarative specifications the language is nonterminal-oriented, in contrast to the production-oriented languages traditionally used in compiler writing systems.

A specification language for one-pass semantic analysis

Automatic production of one-pass compilers from attribute grammars is considered. An examination of a one-pass grammar for the programming language Euclid shows that the present definition of one-pass grammars is too general: the space behaviour of the produced compilers differs from that found in conventional hand-written compilers. A new class of attribute grammars is defined. The class models naturally the use of space in a hand-written compiler. This implies that the compiler produced automatically on the basis of the grammar uses space in the same way as a practical hand-written recursive descent compiler. Furthermore, a graphical notation is introduced as a design tool for obtaining grammars in the proposed class.

Modelling of space‐efficient one‐pass translation using attribute grammars

The object-oriented paradigm is applied to the interpreting of programming languages An intermediate representation of a program is created as a collection of objects representing various entities in the conceptual world of the source language These objects cover both the static and the dynamic aspects of a program As a major advantage of this approach, issues that are traditionally handled by very different techniques (like symbol table management and the generation and execution of intermediate code) can be treated in a unified manner The specification language of an interpreter generator based on these principles is described

Kai Koskimies

Papers

Compiler construction using attribute grammars

The design of a language processor generator

A specification language for one-pass semantic analysis

Modelling of space‐efficient one‐pass translation using attribute grammars

TOOLS: a unifying approach to object-oriented language interpretation