Academia.eduAcademia.edu

Outline

Title
Abstract
Key Takeaways
Figures
Chapter 1 Introduction
Introduction
Procedures
Data Types -
Statistics on the Universal Translator
Chapter 8 Conclusions
Implications for Language Design
Wrong Selector for Case
References

A compiler generator for semantic grammars

Profile image of Lawrence PaulsonLawrence Paulson

1981

Abstract

For the past three years, John Hennessy has assisted my study of programming languages. He suggested that I investigate semantics, and later noted that the compiler generator might be feasible. As the research progressed, John helped me to focus on the most important problems. He made extensive comments on numerous drafts of this thesis and other papers.

Key takeaways
sparkles

AI

  1. The thesis introduces a compiler generator that simplifies language design and implementation.
  2. Semantic grammars effectively combine syntax and semantics, reducing errors and ambiguities in language definitions.
  3. The generator has produced compilers for languages like Pascal and Fortran, demonstrating transportability.
  4. Static and dynamic semantics are critical for efficient compilation and error reporting in programming languages.
  5. The compiler generator enhances debugging and facilitates formal definitions of programming languages.
Figures (52)
# variable identifier # expressions # variables # commands
# variable identifier # expressions # variables # commands
body must be a function or tuple of functions. The code generator creates an entry point for Although the code generator performs few optimizations, it includes those that Burge [6} recommends. It also emits code to delete a bound variable after its last use, located during
body must be a function or tuple of functions. The code generator creates an entry point for Although the code generator performs few optimizations, it includes those that Burge [6} recommends. It also emits code to delete a bound variable after its last use, located during
function. A vector gap does not indicate that the function is undefined; its value may appea the non-nil data: An array block represents part of a function's association list, not the entire
function. A vector gap does not indicate that the function is undefined; its value may appea the non-nil data: An array block represents part of a function's association list, not the entire
The simplifier can reduce (Ax.f)y to f without copying f, if y is the variable at depth 0. This is valid because bound variables are distinguished by depth number, rather than by name.
The simplifier can reduce (Ax.f)y to f without copying f, if y is the variable at depth 0. This is valid because bound variables are distinguished by depth number, rather than by name.

Related papers

Interpreters from functions and grammars
Greg Michaelson

1986

Abstract The addition of context free grammar rules to a functional language simplifies the construction of interpreters from denotational semantic language definitions. Functional abstraction over grammar rules enables the specification and processing of context sensitive language syntax aspects in a functional style.

View PDFchevron_right
Syntax-guided synthesis
Rishabh Singh

2013 Formal Methods in Computer-Aided Design, 2013

The classical formulation of the program-synthesis problem is to find a program that meets a correctness specification given as a logical formula. Recent work on program synthesis and program optimization illustrates many potential benefits of allowing the user to supplement the logical specification with a syntactic template that constrains the space of allowed implementations. Our goal is to identify the core computational problem common to these proposals in a logical framework. The input to the syntax-guided synthesis problem (SyGuS) consists of a background theory, a semantic correctness specification for the desired program given by a logical formula, and a syntactic set of candidate implementations given by a grammar. The computational problem then is to find an implementation from the set of candidate expressions so that it satisfies the specification in the given theory. We describe three different instantiations of the counterexample guided -inductive-synthesis (CEGIS) strategy for solving the synthesis problem, report on prototype implementations, and present experimental results on an initial set of benchmarks.

View PDFchevron_right
An Abstract Machine for Unification Grammars
Shuly Wintner

Arxiv preprint cmp-lg/9709013, 1997

View PDFchevron_right
An Algebra for Semantic Construction in Constraint-based Grammars
Ann Copestake

2001

We develop a framework for formalizing semantic construction within grammars expressed in typed feature structure logics, including HPSG. The approach provides an alternative to the lambda calculus; it maintains much of the desirable flexibility of unificationbased approaches to composition, while constraining the allowable operations in order to capture basic generalizations and improve maintainability.

View PDFchevron_right
Parsing and Generation with Tabulation and Compilation
Koiti Hasida
View PDFchevron_right
Compiling HPSG-style Grammar to an Object-Oriented Language
Junichi Tsujii

This paper describes the compilation techniques used in our HPSG(Pollard and Sag, 1987; Pollard and Sag, 1993)based parser. As the rst step, our parser builds up as fast as possible the parse trees which cover the whole input, by ignoring complex constraints. In the second phase, these ignored constraints are solved, but only for the completed trees covering the whole sentence. Our HPSG compiler generates code for the Common Lisp Object System (CLOS) which is used in the rst phase. The original grammar is written using feature structures and denite clause programs(Carpenter, 1992). The compiled code contains unication routines specialised for a given grammar and a xed parsing strategy, i.e., bottom-up parsing, as well as reduced constraints derived from the original grammar. Preliminary experiments show that our parser can be faster than a parser with conventional unication routines.

View PDFchevron_right
A generator for production quality compilers
Hanspeter Mössenböck

Compiler Compilers, 1991

This paper presents a compiler description language and its implementation Coco/R (Compiler Compiler for Recursive Descent). Coco/R reads an attributed EBNF grammar of a language and translates it into a recursive descent parser and a scanner for that language. The programmer has to supply a main program that calls the parser and semantic modules that are called from within the parser. Coco/R evolved from two predecessors: the scanner generator Alex [Mrss86] and the parser generator Coco [ReM689]. Their input languages were merged and simplified due to our experiences with these tools over several years (a similar tool with a slightly different motivation also emerged from Alex and Coco [DoPi90]). Using Coco/R, compilers can be generated that are as efficient as hand-coded and carefully optimized production quality compilers. Almost as important as efficiency is the simplicity and adequacy of the system. Programmers are not willing to use a tool if it does not come in handy to their work, if it uses an arcane notation or a bulk of options and special cases. Coco/R puts simplicity and efficiency over power.

View PDFchevron_right
Using annotated grammars for the automated generation of program transformers
Diego Ordóñez Camacho

Ingénierie Dirigée par les Modéles, IDM2007, proceedings, 2007

RÉSUMÉ. ABSTRACT. When confronted with a family of different domain-specific programming languages, each with their own particular syntax but providing essentially the same semantic constructs, often the need arises to transform programs between any of these languages. This is for example the case for the domain of satellite operation languages, where every vendor or mission control centre uses its own proprietary language. In previous work, we proposed a generic technique to automatically generate program ...

View PDFchevron_right
A Symmetrical Approach to Parsing and Generation
Marc Dymetman

Lexica! Grammars are a class of unification g,'ammars which share a fixed rule component, for which lhere exists a simple left-recursion elimination transformation. The parsing and generation programs ae seen as two dual non-left-recursive versions of the original grammar, and are implemented through a standard top-down Prolog interpreter. Formal criteria for termination are given as conditions on lexical enlrics: during parsing as well as during generution the processing of a lexical entry consumes some amount of a guide; the guide used for parsing is a list of words remaining to be analyzed, while the guide for genration is a list of the semantics of constituents waiting to be generated.

View PDFchevron_right
Deriving Compilers from Monadic Semantics
Samuel Kamin

The monadic style of language specification [6, 16, 15, 26] has the advantages of modularity and extensibility: it is simple to add or change features in an interpreter to reflect modifications in the source language. It has proven difficult to extend the method to compilation, because there is considerable interaction between different features. We demonstrate that by introducing machine-like stores (code and data) into the monadic semantics (to achieve pass separation [12]) and then partially evaluating the resulting semantic expressions, we can achieve many of the same advantages for a compiler as for an interpreter. A number of language constructs and features are compiled: expressions, while loops, CBV and CBN evaluation of -expressions, dynamic scoping, and various imperative features. The treatment of recursive procedures is outlined as well. The resulting method allows compilers to be constructed in a mix-and-match fashion just as in a monad-structured interpreter. K...

View PDFchevron_right

References (71)

  1. Alfred V. Aho, Jeffrey 0. Ullman. Principles of CompilerDesign.
  2. Addison-Wesley, 1978. " j American National Standards Institute. Clarification of Fortran Standards: Second Report. Communications of the ACM , October, 1971.
  3. American Standards Association. Fortran vs. Basic Fortran. Communications of the ACM , October, 1964.
  4. F. L. Bauer, J. Eickel (editors).
  5. Compiler Construction: An Advanced Course.
  6. Gregor V. Bochmann. Semantic Evaluation from Left to Right. Communications of the ACM :55 -62, February, 1976.
  7. W. H. Burge. Recursive Programming Techniques.
  8. Addison-Wesley, 1976.
  9. -J. Dahl, E. W. Dijkstra, C. A. R. Hoare. Structured Programming. Academic Press, 1972. Department of Defense.
  10. STEELMAN Requirements for High Order Computer Programming Languages 1978. James E. Donahue. Complementary Definitions of Programming Language Semantics. Springer-Verlag , 1976.
  11. J. H. Eriksen, B. B. Jensen, 6.6. Kristensen, 0. L. Madsen. The BOBS-System.
  12. * - Michael Gordon. The Denotational Description of Programming Languages: An Introduction. Springer-Verlag, 1979.
  13. Michael Gordon, R. Milner, C. Wadsworth.
  14. Edinburgh LCF.
  15. Susan L. Graham, Charles B. Haley, William N. Joy. Practical LR Error Recovery. SIGPLAN Notices 14:168-175, August, 1979. Proceedings of the SIGPLAN Symposium on Compiler Construction. John L. Hennessy. The Stanford Pascal Parser Generator. Technical Report, Stanford University, 1981. In preparation.
  16. C. A. R. Hoare. Hints on Programming Language Design, Technical Report CS-403, Computer Science Department, Stanford University, October, 1 973.
  17. C. A. R. Hoare, N. Wirth. An Axiomatic Definition of the Programming Language Pascal. Acta lnformatica :335 -355,1973.
  18. J. D. Ichbiah et al. Preliminary Ada Reference Manual. SIGPLAN Notices, June, 1979.
  19. Mehdi Jazayeri, William F. Ogden, William C. Rounds. The Intrinsically Exponential Complexity of the Circularity Problem for Attribute Grammars. Communications of the ACM :697 -706, December, 1975.
  20. Kathleen Jensen, Niklaus Wirth. Pascal User Manual and Report.
  21. P. Jesperson, M. Madsen, H. Riis. NEATS, New Extended Attribute Translation System. Technical Report, computer Science Department, Aarhus University, Denmark, 1978. Cited in Watt and Madsen [63].
  22. Stephen C. Johnson. YACC: Yet Another Compiler-Compiler.
  23. Neil D. Jones (editor). Semantics-Directed Compiler Generation. Springer:Verlag, 1980.
  24. Neil D. Jones, Henning Christiansen. Control Flow Treatment in a Simple Semantics-Directed Compiler Generator. Technical Report PB-137, Aarhus University, Denmark, 1981.
  25. 1241 Neil D. Jones, Michael Madsen. Attribute-Influenced LR Parsing. Pages 393 -407 of Jones [22], 1980.
  26. Neil D. Jones, David A. Schmidt. Compiler Generation lrom Denotational Semantics. Pages 70 -93 of Jones [22], 1980. a
  27. D. E. Knuth. The Remaining Trouble Spots in ~lgol60. Communications of the ACM 10:611-618, October, 1967. 1271 D. E. Knuth. Semantics of Context-Free Languages. Mathematical Systems Theory 2:127 -145, February, 1968. Corrected in 1971 volume, pages 95 -96.
  28. C. H. A. Koster. Affix Grammars.
  29. In J. E. L. Peck (editor), Algol 68 Implementation, pages 95 -109. North-Holland, 1971.
  30. C. H. A. Koster. Using the CDL Compiler-Compiler. Pages 366 -426 of Bauer and Eickel[4], 1976. 1301 P.JiLandin. The Mechanical Evaluation of Expressions. Computer Journal 6:308 -320, April, 1964.
  31. Ole L Madsen. On Defining Semantics by Means of Extended Attribute Grammars. Technical Report DAIMI PB-109, Computer Science Department, Aarhus University, Denmark, January, 1980. Pages 259 -299 of Jones [22].
  32. Ole L. Madsen. Towards a Practical and General Translator Writing System. Technical Report, Computer Science Department, Aarhus University, Denmark, March, 1980.
  33. Zohar Mnna. Mathematical Theory of Computation.
  34. McGraw-Hill, 1974.
  35. M. Marcotty, H. F. Ledgard, G. V. Bochmann. A Sampler of Formal Definitions, Computing Surveys :I91 -276, June, 1976.
  36. Brian H. Mayoh. Attribute Grammars and Mathematical Semantics. Technical Report DAIMI PB-90, Computer Science Department, Aarhus University, Denmark, August, 1978.
  37. John McCarthy. Towads a Mathematical Science of Computation. -? .
  38. In C. M. Popplewell (editor), Information Processing 6z1 pages 21 -28. North-Holland, 1963.
  39. R. E. Milne, C. Srachey.
  40. A Theory of Programming Language Semantics.
  41. John Wiley, 1976. Published in Great Britain by Chapman and Hall.
  42. D. R. Milton, L. W. Kirchhoffl B. R. Rowland. An ALL(1) Compiler Generator.
  43. S I G P U N Notices 14~152-157, August, 1979. Proceedings of the SIGPLAN Symposium on Compiler Construction. Peter D. Mosses. The Mathematical Semantics of Algol 60. Technical Report PRG-012, Programming Research Group, Oxford University, 1974. Peter D. Mosses.
  44. S/S: Semantics /mp/ementation System. Reference Manual and User Guide. Technical Report DAIMI MD-33, Computer Science Department, Aarhus University, Denmark, 1 Q79.
  45. Peter D. Mosses. SIS: Semantics Implementation System. Tested Examples. Technical Report DAIMI MD-30, Computer Science Departmentl Aarhus University, Denmark, 1979.
  46. Peter D. Mosses. Mathematical Semantics and Compiler Generation. PhD thesis, Oxford University, 1975.
  47. P. Naur, J. W. Backus, F. 1. Bauer, J. Green, C. Katz, J. McCarthy, A. J. Perlis, H. Rut.Mauser, K. Samuelson, B. Vauquois, J. H. Wegstein, A. van Wijngaardenl M. Woodger. Revised Report on the Algorithmic Language Algol 60. Communications of the ACM 6:l -17, January, 1963. [MI Derek C. Oppen. Pretty Printing. ACM Transactions on Programming Languages and Systems :465 -483, October, 1980. -. Lawrence Paulson, John Hennesy. Semantic Grammars: A Formalism for Defining the Syntax and Semantics of Programming Languages. Technical Report, Stanford University, 1980. Submitted to the Journal of the ACM.
  48. G. D. W i n . Call-byme, Call-byvalue, and the A-~lculus. Theoretical Computer Science : I 25 -159,1975.
  49. Peter C. Poole. Portabk and Adaptable Compilers. Pages 427 -497 of Bauefand Eickel[4], 1976.
  50. D. P. Pozefsky. Building Efficient Pass-Oriented Attribute Grammar Evaluators. PhD thesis, University of North Carolina at Chapel Hill, 1Q79.
  51. Kari-Jouko Raihal Mikko Saarinen, Eljas Soisalon-Soininen, Martti Tienari. The Compiler Writing System HLP &ielsinki Language processor^. Technical Report A-1 978-2, Department of Computer Science, University of Helsinki, Finland, 1978.
  52. Kari-Jouko Riiha. Experiences with the Compiler Writing System HLP. Pages 350 -362 of Jones [22], 1 Q80.
  53. Kari-Jouko Raiha. Bibliography on Attribute Grammars. SIGPUN Notices 15135 -44, March, 1980.
  54. Martin Raskovsky. Step by Step Generation of a Compiler for Flow Diagram Language with Jumps. Technical Report CSM-42, Department of Computer Science, University of €se Junel 1Q81.
  55. Martin Raskovskyl Phil Collier. From standard to Implementation Denotational Semantics. Pages 94 -139 of Jones [22], 1980.
  56. A. H. J. Sale. Pascal Compatibility Report. Technical Report R77-5* Department of Information Science, University of Tasmania, November, 1977.
  57. R. W. Scheifler. A Denotational Semantics of CLU. Technical Rep06 TR-201, ~aboratory for Computer Sciencel M.I.T., 1978. Ravi Sethi. Circular Expressions: Elimination of Static Environments, In S. Even, 0. Kariv (edit~rs)~ Eighth International Colloquium on Automata, Languages and Programming, pages 378 -392. Springer-Verlag, 1981.
  58. Ravi Sethi. Control Flow Aspects of Semantics Directed Compiling. Technical Reportl Bell Laboratories, Murray Hill, New Jersy 07974,1981. Joseph E. Stoy. Denotational Semantics: The Scott-Strachey Approach to Programming Language Theory.
  59. M. I. T. Press, 1978.
  60. R. D. Tennent. Mathematical Semantics of SNOBOL4.
  61. In Symposium on Principles of Programming Languages, pages 95 -107. Association for Computing Machineryl 1973.
  62. R. D. Tennent. The Denotational Semantics of Programming Languages, Communications of the ACM :437 -4m1 August, 1976.
  63. R. D. Tennent.
  64. A Denotational-Definition of the Programming Language Pascal. Technical Report 77-4T1 Department of Computing and Information Science, Queen's Universityl Kingston, Ontario, 1977.
  65. A. van Wijngaarden, 6. J. Maillouxl J. E. L. Peckl C. H. A. Kosterl M. Sirttzoff, C. H. Lindsey, L. G. L. T. Meertens, R. G. Fisker. Revised Report on the Algorithmic Language Algol 68. Springer-Verlag, 1976.
  66. David A. Watt, Ole L. Madsen. Extended Attribute Grammars. Technical Report DAIMI PB-1051 Computer Science Department, Aarhus University, Denmarkl Novemberl 1979.
  67. David A. Watt. An Extended Attribute Grammar for Pascal. SIGPLAN Notices 14:60-74, February, 1979.
  68. David A. Watt. Rule Splitting and Attribute-Directed Parsing. Pages 363 -382 of Jones [22],1980.
  69. J. Welsh, W. JSneeringer, C. A. I?. Hoare. Ambiguities and Insecurities in Pascal. Software Practice and Experience 7:685 -696, November-December, 1977.
  70. Wayne T. Wiiner. Declarative Semantic Definition. PhD thesis, Stanford University, 1971. Computer Science Report STAN-CS-233-71.
  71. 1681 Niklaus Wirth. Algorithms i Data Structures = Programs. Prentice-Hall, 1976. .

Related papers

A semantics-directed compiler generator
Lawrence Paulson

1982

View PDFchevron_right
Automatic Synthesis of Semantics for Context-free Grammars
Bharat Jayaraman

We are investigating the mechanical transformation of an unambiguous context-free grammar (CFG) into a de nite-clause grammar (DCG) using a nite set of examples, each of which is a pair hs; mi, where s is a sentence belonging to the language de ned by the CFG and m is a semantic representation (meaning) of s. The resulting DCG would be such that it can be executed (by the interpreter of a logic programming language) to compute the semantics for every sentence of the original DCG. Three important assumptions underlie our approach: (i) the semantic representation language is the simply typed-calculus; (ii) the semantic representation of a sentence can be obtained from the semantic representations of its parts (compositionality); and (iii) the structure of the semantic representation determines its meaning (intensionality). The basic technique involves an enumeration of parse trees for sentences of increasing size; and, for each parse tree, a set of equations over (typed) function variables that represent the meanings of the constituent subtrees is formulated and solved by means of a higher-order uni cation procedure. The solutions for these function variables serve to augment the original grammar in order to derive the nal DCG. A technique called partial execution is used to convert, where possible, the generated higher-order DCG into a rst-order DCG, to facilitate e cient bidirectional execution. In the appendix, we provide detailed illustration of the use of such a system for storing and retrieving information contained in natural language sentences. Based on our experimentation, we conclude that an improved version of this system will facilitate rapid prototyping of natural language front-ends for various applications.

View PDFchevron_right
Compiler generation from relational semantics
Mads Dam

Lecture Notes in Computer Science, 1986

We consider the problem of automatically deriving correct compilers from relational semantic specifications of programming languages. A relational semantics is an assignment of initial-state final-state relations (defined by means of proof rules) to programs. Compilers are generated in three steps. First, the language definition is transformed into a stack semantics in which the sto~age of semantic values is made explicit. Next, stack rules are assembled into a socalled language scheme containing exactly one rule for each language construct. We consider languages for which non-deterministic branches may be replaced by deterministic ones. Finally, rules are expanded for the purpose of recursion detection, thus obtaining schemes which may be used for code generation in a syntax-directed compiler.

View PDFchevron_right
BoB: Best of Both in Compiler Construction Bottom-up Parsing with Top-down Semantic Evaluation
ACSIJ Journal

Compilers typically use either a top-down or a bottom-up strategy for parsing as well as semantic evaluation. Both strategies have advantages and disadvantages: bottom-up parsing supports LR(k) grammars but is limited to S-or LR-attribution while topdown parsing is restricted to LL(k) grammars but supports Lattribution. The goal of the work described herein was to combine the advantages of both strategies. The result is the compiler generator BoB, mainly a preprocessor for Flex and Bison (modern versions of Lex and Yacc). BoB processes compiler descriptions written in Cocol4BoB which supports L-attributed LALR(1) grammars and generates input files for Flex and Bison. Compilers generated by the BoB-Flex&Bison toolchain use bottom-up parsing and top-down semantic evaluation. So developers do not have to struggle with LL(1) conflicts and can use inherited as well as synthesized attributes in semantic actions. Another benefit of BoB is its simple yet powerful compiler description language.

View PDFchevron_right
A Correspondence Between Denotational Semantics and Code Generation
Martin Raskovsky

Doctorate Thesis, 1982

We describe a method for the systematic derivation, or automatic generation - from the formal denotational semantic specification - of an efficient compiler's code generation phase,producing efficient code for real machines. The method has been successfully implemented and tested with languages as complex as GEDANKEN! The method has been used to implement a compiler-compiler which inputs the semantic specification of a programming language written in a standard denotational form, analyses it in the light of its semantic contents, decides upon certain predecided general implementation issues and outputs a program written in the systems programming language BCPL. This program constitutes the type .checking and code generation phases of a compiler for the given language. Its structure and operation is in effect essentially the same that we would have produced by hand. The only hand coding is the interface for the particular target machine, required for both the primitive functionsof the original specification and those introduced by the compiler-compiler. For the latter, our system provides a library of routines to generate code for the DEC-10 system. So that in all the examples we tried, we only had to hand codethe former. The parser is separately generated with an LLl system which also generates BCPL procedures.

View PDFchevron_right
580 California St., Suite 400
San Francisco, CA, 94104
© 2025 Academia. All rights reserved