We describe motivation, design, use, and implementation of higher-order abstract syntax as a central representation for programs, formulas, rules, and other syntactic objects in program manipulation and other formal systems where matching and substitution or unification are central operations. Higher-order abstract syntax incorporates name binding information in a uniform and language generic way. Thus it acts as a powerful link integrating diverse tools in such formal environments. We have implemented higher-order abstract syntax, a supporting matching and unification algorithm, and some clients in Common Lisp in the framework of the Ergo project at Carnegie Mellon University.

/pdf/higher-order-abstract-syntax-4w9dht3b8x.pdf

Higher-order abstract syntax

SDF is a formalism for the definition of syntax which is comparable to BNF in some respects, but has a wider scope in that it also covers the definition of lexical and abstract syntax. Its design and implementation are tailored towards the language designer who wants to develop new languages as well as implement existing ones in a highly interactive manner. It emphasizes compactness of syntax definitions by offering (a) a standard interface between lexical and context-free syntax; (b) a standard correspondence between context-free and abstract syntax; (c) powerful disambiguation and list constructs; and (d) an efficient incremental implementation which accepts arbitrary context-free syntax definitions. SDF can be combined with a variety of programming and specification languages. In this way these obtain fully general user-definable syntax.

/pdf/the-syntax-definition-formalism-sdf-reference-manual-3ry6dxnbmi.pdf

The syntax definition formalism SDF—reference manual—

Over the last decade, considerable progress has been made in solving the problems of automatic generation of programming/development environments, given a formal definition of some programming or specification language. In most cases, research has focused on the functionality and efficiency of the generated environments, and, of course, these aspects will ultimately determine the acceptance of environment generators. However, only marginal attention has been paid to the development process of formal language definitions itself. Assuming that the quality of automatically generated environments will be satisfactory within a few years, the development costs of formal language definitions will then become the next limiting factor determining ultimate success and acceptance of environment generators.In this paper we describe the design and implementation of a meta-environment (a development environment for formal language definitions) based on the formalism ASF + SDF. This meta-environment is currently being implemented as part of the Centaur system and is, at least partly, obtained by applying environment generation techniques to the language definition formalism itself. A central problem is providing fully interactive editing of modular language definitions such that modifications made to the language definition during editing can be translated immediately to modifications in the programming environment generated from the original language definition. Therefore, some of the issues addressed are the treatment of formalisms with user-definable syntax and incremental program generation techniques.

/pdf/a-meta-environment-for-generating-programming-environments-4v4uwywxnq.pdf

A meta-environment for generating programming environments

Graphs play an important role within many areas of computer science. Rule-based languages, on the other hand, are well-suited for the description of transformation or inference processes on complex data structures. Why not combining two successful principles in one formalism? This is the common vision of the graph transformation community and the main motivation behind the development of PROGRES, a visual language that supports PROgramming with Graph REwriting Systems. The language PROGRES was developed having the following three design goals in mind: (1) Distinguish between data deenition and manipulation activities and use graph schemata to type-check graph transformation rules. (2) Do not rely on the rule-oriented paradigm for all purposes, but support also imperative programming with control structures. (3) Refrain users from the task to guarantee connuence of deened rules by keeping track of rewriting connicts and backtracking out of dead-end derivations. Its accompanying programming environment ooers assistance for creating, analyzing , compiling, and debugging graph transformations as well as for rapid prototyp-ing activities. Being an integrated set of tools with support for intertwining these activities, it combines the exibility of interpreted languages with the safeness of compiled and statically typed languages.

The PROGRES approach: language and environment

The PSG programming system generator developed at the Technical University of Darmstadt produces interactive, language-specific programming environments from formal language definitions. All language-dependent parts of the environment are generated from an entirely nonprocedural specification of the language's syntax, context conditions, and dynamic semantics. The generated environment consists of a language-based editor, supporting systematic program development by named program fragments, an interpreter, and a fragment library system. The major component of the environment is a full-screen editor, which allows both structure and text editing. In structure mode the editor guarantees prevention of both syntactic and semantic errors, whereas in textual mode it guarantees their immediate recognition. PSG editors employ a novel algorithm for incremental semantic analysis which is based on unification. The algorithm will immediately detect semantic errors even in incomplete program fragments. The dynamic semantics of the language are defined in denotational style using a functional language based on the lambda calculus. Program fragments are compiled to terms of the functional language which are executed by an interpreter. The PSG generator has been used to produce environments for Pascal, ALGOL 60, MODULA-2, and the formal language definition language itself.

https://link.springer.com/content/pdf/10.1007%2F3-540-19027-9_25.pdf

The PSG system: from formal language definitions to interactive programming environments

The programming system generator developed at the Technical University of Darmstadt generates sophisticated interactive programming environments from formal language definitions. From a formal, entirely non-procedural definition of the language's syntax, context conditions and denotational semantics, it produces a hybrid editor, an interpreter and a library system. The editor allows both structure editing and text editing, guaranteeing immediate recognition of syntactic and semantic errors. The generator has been used to generate environments for PASCAL, MODULA-2 and the formal language definition language itself. A brief description of the generated environments and the definition language is given, and our experiences with formal language definitions are discussed from the language definer's point of view as well as from the programmer's point of view using the generated environments.

The PSG - Programming System Generator

/pdf/the-psg-system-from-formal-language-definitions-to-p0h7mfau1c.pdf

The PSG System: From Formal Language Definitions to Interactive Programming Environments

The PSG-Programming System Generator developed at Darmstadt produces interactive language-specific programming environments from formal language definitions. From an entirely nonprocedural specification of the language's syntax, context conditions and denotational semantics, it produces a hybrid editor, an interpreter and a library system. In this paper, we give a detailed description of PSG-generated environments. The main features of PSG editors are discussed. In particular, we describe the interplay between text editing and structure editing, the PSG fragment concept, the interactive handling of syntax and context errors and the context-sensitive error prevention mechanisms. We include an example editing session demonstrating the user interface of the PSG implementation on PERQ workstations, utilizing graphical devices.

Context-sensitive Editing with PSG Environments

We present a system which generates interactive high-level debugging systems from formal language definitions. The language definer has to specify a denotational semantics augmented with a formal description of the language specific debugging facilities. The generated debugger offers the traditional features such as tracing programs, setting breakpoints, displaying variables etc; interaction with the user is always on language level rather than on machine level. The concept has been implemented as part of the PSG-Programming System Generator, and has successfully been used to generate debuggers for Pascal and Modula-2. The core of the implementation consists of an interpreter for a functional language, which has been extended with the language-independent mechanisms needed in order to allow interaction with the user during program execution.

Rolf Bahlke

Papers

The PSG system: from formal language definitions to interactive programming environments

The PSG - Programming System Generator

The PSG System: From Formal Language Definitions to Interactive Programming Environments

Context-sensitive Editing with PSG Environments

A generator for language-specific debugging systems