Recursive Descent Research Articles

A project-based course in compiler construction

The paper describes the experience gained by teaching a project-based course in Compiler Construction. The course is a blend of theoretical concepts and practical considerations that go into the development of a compiler. A project in compiler writing is an important component of this course. ASP, a subset of standard PASCAL, is used as the source language. The compiler for ASP is to be developed in various phases: character manipulator, lexical analyzer, syntax analyzer, semantic analyzer, and code generator. Recursive descent method is used to parse the various syntactic entities. The code generator emits code for a hypothetical machine called AOC (ALGOL Object Code). A simulator executes this code.

Compact recursive‐descent parsing of expressions

AbstractCompiler writing tools, such as parser generators, are‐commonly used to build new operators. Nevertheless, constructing compilers by hand remains common. Such compilers are often built using recursive‐descent parsing for most of the language and operator‐precedence parsing for expressions. This paper describes a simple technique for parsing expressions using recursive descent that avoids the usual proliferation of procedures that occurs when recursive descent is used to parse expressions. By taking advantage of the similarity of the productions describing expressions in most languages, the n + 1 procedures usually required to parse expressions with n precedence levels can be replaced with a table and two procedures.

A portable compiler for microcomputers

The implementation of a microprocessor programming language, called MBPL is introduced. The primary requirement for choosing the language implementation method is the compiler portability. To achieve this, an intermediate language and virtual processors are used. The compiler is developed along with the recursive descent method. It is written in MBPL using the bootstrap principle. The compiler generates an object code which has to be interpreted by a virtual processor. The translation process is described by a syntax-directed translation scheme over an extended context-free input grammar.

The cost of a generated parser

AbstractThe ‘fact’ that compilers employing generated parsers suffer significant performance degradation dis‐a‐vis recursive descent compilers is entrenched in the folklore of computing. We give detailed measurements that support this belief when the entire compiler is written in Pascal. We then define a general interface for a parsing module that hides significantly more information than usual, simplifying the process of generation and integration. This interface makes an assembly‐coded parse table interpreter feasible without changing the language used for the remainder of the compiler. When the parse table interpreter is written in assembly language, the costs of the generated parser are essentially the same as those for recursive descent. (A minor space/time trade‐off is possible, with the recursive descent implementation being slightly bigger and slightly faster.)

Follow set error recovery

AbstractFollow set error recovery is a popular technique, implemented as part of a recursive descent parser, for recovering from syntax errors by editing the input string at the point of error detection. A formal description shows that follow set error recovery is, in actual fact, a family of similar techniques differing according to how follow set is defined. A general algorithm for this family of schemes is offered. Standard accounts mention and make use of non‐systematic, almost ad hoc, additions which improve the performance of the technique. It is shown that some of these additions can be systematized using error productions. Criteria for assessment of the technique are offered. Using these criteria and a database of over 100 example programs three different follow set schemes are assessed with respect to each other.

The implementation of the attributed recursive descent architecture in VAX-11/780 microcode

This paper describes a case study in the implementation of a special purpose architecture on a particular microprogrammable engine. The host engine used is the VAX-11/780; the target architecture is one tailored for implementing recursive descent translators. The paper describes the mapping of the target resources onto the host machine including a discussion of the issues involved in interfacing with the normal VAX environment. The architecture specification does not mandate the exact bit-level representation of the target architecture instructions allowing a more efficient emulator to be constructed. Many of the important design decisions involve choosing instruction representations to effectively utilize the host engine. The paper concludes with discussion of the considerable shortcomings of this approach, of the suitability of the VAX-11/780 as an underlying engine for the target architecture, and of the implications of the study for universal host machines.

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

AbstractAutomatic 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.

A simple, natural notation for applicative languages

Abstract : Many non-specialists are intimidated by the mathematical appearance of most applicative, functional, and very-high-level languages. This report presents a simple notation that has an unintimidating, natural-language appearance and that can be adapted to a variety of languages. The paper demonstrates its use as an alternate syntax for LISP, PROLOG, Backus' FP, relational programming, and relational database retrievals. The grammar's eight productions can be handled by a simple recursive-descent parser. (Author)

A note on error recovery in recursive descent parsers

A note on error recovery in recursive descent parsers

From English to logic: context-free computation of conventional logical translation

We describe an approach to parsing and logical translation that was inspired by Gazdar's work on context-free grammar for English. Each grammar rule consists of a syntactic part that specifies an acceptable fragment of a parse tree, and a semantic part that specifies how the logical formulas corresponding to the constituents of the fragment are to be combined to yield the formula for the fragment. However, we have sought to reformulate Gazdar's semantic rules so as to obtain more or less 'conventional' logical translations of English sentences, avoiding the interpretation of NPs as property sets and the use of intensional functors other than certain propositional operators. The reformulated semantic rules often turn out to be slightly simpler than Gazdar's. Moreover, by using a semantically ambiguous logical syntax for the preliminary translations, we can account for quantifier and coordinator scope ambiguities in syntactically unambiguous sentences without recourse to multiple semantic rules, and are able to separate the disambiguation process from the operation of the parser-translator. We have implemented simple recursive descent and left-corner parsers to demonstrate the practicality of our approach.

Hidden surface elimination for complex graphical scenes

An extension to the Algorithm of Recursive Descent, introduced by Clark is presented for improving high speed techniques in hidden surface elimination. Whenever the average number of opaque primitives per occupied raster element becomes large, the algorithm presented tends to eliminate unnecessary depth evaluations. In complex graphical scenes which are executed by parallel processing structures interactively, the presented algorithm may provide considerable processing savings in related computer graphics processes.

A Coroutine Approach to Parsing

A method is presented for parsing syntactic constructs that are permitted to appear independently anywhere in a program. Some examples include comments, macros, and constructs for conditional compilation. Each such construct is defined by its own grammar and parsed by a separate coroutine. The coroutine model of parsing allows the program text to be parsed in one pass despite the syntactic inconsistencies among the program text and the additional constructs. The usefulness of the model is demonstrated by showing how a production language parsing method is extended to handle multiple syntax specifications. The implementation of conditional compilation by carrying along two parses in a coroutine manner is also given. The utility of the model is further demonstrated by showing its adaptation to a recursive descent parser.

Comments on an error‐recovery scheme by Hartmann

AbstractA. C. Hartmann has described what is probably the definitive error‐recovery method for recursive‐descent parsers. Some comments are made on possible improvements, and an error is corrected.

Evaluating and Improving Recursive Descent Parsers

Time formulas are symbolic formulas which express the execution time of a program as a function of its input data and of variables representing the time to execute individual operations (e.g., push, pop, transfer, etc.). It is shown that in many cases the time formulas for recursive descent parsers may be generated automatically by a simple inspection of the parser code. These time formulas are instrumental in estimating the gains attained by various types of optimizations. Several of these optimizations are presented and their efficiency gains are estimated. A parser for a simple programming language is generated, optimized, and evaluated using the proposed techniques.

Parsing macro grammars top down

A top-down parsing scheme for macro grammars is proposed. It extends the recursive descent method frequently used in context-free parsing. It is shown to be decidable if a macro grammar is top-down parsable. Nearly matching lower and upper bounds for the complexity of the decision procedure are derived. A time and space efficient recognition algorithm is described.

The META/REDUCE translator writing system

The META/REDUCE translator writing system operates in a LISP environment closely interfaced with both LISP and REDUCE syntax. The language supports: BNF like syntax, recursive descent parsing schemes, lexical primitives, symbol table primitives, and automatic syntax error message generation. A complete simple arithmetic expression evaluator provides an introduction to the capabilities of the system. The body of the work describes the control constructs and primitives of the system. The paper is completed with the description of a working interpreter for a subset of a contemporary programming language. It is assumed that the reader has some familiarity with LISP 1.5 and REDUCE.

The design of a space efficient compiler

Writing a compiler for a small machine with minimal software support can be quite difficult because the program is long and debugging aids are usually inadequate. In addition, the usual techniques for compiler writing tend to produce programs which are quite large when compared to, for example, a BASIC interpreter. This frustrates efforts for producing compilers on small machines. We describe a method which can be used to reduce the size of a compiler and simultaneously provide good debugging tools. The resulting compiler sacrifices little in terms of execution speed (in part because compilers on minicomputers are often I/O bound). We have used this method to write an MPL [1] compiler for a Microdata 32/S minicomputer. The compiler requires approximately 12K bytes of memory as opposed to 32K bytes required by the compiler produced by the manufacturer, and compiles at essentially the same speed. Appendix II outlines the syntax of the MPL language and is included to illustrate the size of the language being compiled. MPL is based on PL/I and is quite similar to the PL/M* [2] language developed by the INTEL Corporation. The method described here uses an interpretive language for writing the compiler. Thus the interpreter is the only machine language program written. We coded the interpreter in MPL and used a cross compiler to compile it, however, the interpreter could have been easily coded in assembly language. Figure 1 illustrates the savings of the interpretive language over machine code. The procedure IF_STAT is typical of a routine which might appear in a recursive descent compiler for MPL. The gain in space occurs because machine language instructions carry too much information content when applied to a special purpose (such as compiling). Note for example that a subroutine call for the Microdata requires 6 bytes, but all that is really needed is an opcode to indicate a call and a byte to indicate which of a few subroutines is to be called.

Analyses of deterministic parsing algorithms

This paper describes an approach for determining the minimum, maximum, and average times to parse sentences acceptable by a deterministic parser. These quantities are presented in the form of symbolic formulas, called time-formulas. The variables in these formulas represent not only the length of the input string but also the time to perform elementary operations such as pushing, popping, subscripting, iterating, etc. By binding to the variables actual numerical values corresponding to a given compiler-machine configuration, one can determine the execution time for that configuration. Time-formulas are derived by examining the grammar rules and the program representing the algorithm one wishes to analyze. The approach is described by using a specific grammar that defines simple arithmetic expressions. Two deterministic parsers are analyzed: a top-down recursive descent LL(1) parser, and a bottom-up SLR(1) parser. The paper provides estimates for the relative efficiencies of the two parsers. The estimates applicable to a specific machine, the PDP-10, are presented and substantiated by benchmarks. Finally, the paper illustrates the proposed approach by applying it to the analyses of parsers for a simple programming language.

Hierarchical geometric models for visible surface algorithms

The geometric structure inherent in the definition of the shapes of three-dimensional objects and environments is used not just to define their relative motion and placement, but also to assist in solving many other problems of systems for producing pictures by computer. By using an extension of traditional structure information, or a geometric hierarchy, five significant improvements to current techniques are possible. First, the range of complexity of an environment is greatly increased while the visible complexity of any given scene is kept within a fixed upper limit. Second, a meaningful way is provided to vary the amount of detail presented in a scene. Third, “clipping” becomes a very fast logarithmic search for the resolvable parts of the environment within the field of view. Fourth, frame to frame coherence and clipping define a graphical “working set,” or fraction of the total structure that should be present in primary store for immediate access by the visible surface algorithm. Finally, the geometric structure suggests a recursive descent, visible surface algorithm in which the computation time potentially grows linearly with the visible complexity of the scene.

Hierarchical geometric models for visible-surface algorithms

The research described in this paper addresses the problems associated with the design of systems for efficiently producing computer-generated pictures and picture sequences of very complex, three-dimensional environments. The thesis of the research is that the geometric structure inherent in the definition of the shapes of three-dimensional objects and environments must be used not just to define their relative motion and placement but also to assist in solving many other problems of systems for producing pictures by computer.The implications are that by using an extension of traditional structure information, or a geometric hierarchy, five significant improvements to current techniques are possible. First, the range of complexity of an environment is greatly increased while the visible complexity of any given scene is kept within a fixed upper limit. Second, a meaningful way is provided to vary the amount of detail presented in a scene both according to the screen area occupied by the objects in the scene and according to camera and object motions. Third, by using the geometric hierarchy, "clipping" becomes a very fast logarithmic search for the resolvable parts of the environment within the field-of-view. Fourth, by using this positional hierarchy in conjunction with a storage hierarchy of the sort used in virtual memory computing systems, frame-to-frame coherence and clipping define a graphical "working set", or fraction of the total structure that should be present in primary store for immediate access by the visible-surface algorithms. Finally, the proposed structural framework suggests a new recursive descent visible-surface algorithm in which the computation time grows almost linearly with a scene's visible complexity rather than as a worse than linear function of its object-space complexity.