Compiler Construction

data type: An abstraction of a data object on which a number of actions can be performed. Declaration is separate from instantiation, and hence many instances may exist. (Example { A stack abstraction providing the operations push, pop, top, etc.) Variable: An abstraction of a data object on which exactly two operations, fetch and store, can be performed. (Example { An integer variable in most programming languages.) Abstract data types can be implemented via packages: The package de nes a data type to represent the desired object, and procedures for all operations on the object. Objects are then instantiated separately. When an operation is invoked, the particular object to which it should be applied is passed as a parameter to the operation procedure. The overall compiler structure that we shall use in this book is outlined in Figures 1.4 through 1.8. Each of these gures describes a single step in the decomposition. The central block of the gure speci es the problem being decomposed at this step. To the left are the data structures from which information is obtained, and to the right are those to which information is delivered. Below is the decomposition of the problem, with boxes representing subtasks. Data structures used for communication among these subtasks are listed at the bottom of the gure. Each box and each entry in any of the three data lists corresponds to a module of the compiler. It is important to note that Figures 1.4 through 1.8 re ect only the overall structure of the compiler; they are not owcharts and they do not specify module interfaces.data types can be implemented via packages: The package de nes a data type to represent the desired object, and procedures for all operations on the object. Objects are then instantiated separately. When an operation is invoked, the particular object to which it should be applied is passed as a parameter to the operation procedure. The overall compiler structure that we shall use in this book is outlined in Figures 1.4 through 1.8. Each of these gures describes a single step in the decomposition. The central block of the gure speci es the problem being decomposed at this step. To the left are the data structures from which information is obtained, and to the right are those to which information is delivered. Below is the decomposition of the problem, with boxes representing subtasks. Data structures used for communication among these subtasks are listed at the bottom of the gure. Each box and each entry in any of the three data lists corresponds to a module of the compiler. It is important to note that Figures 1.4 through 1.8 re ect only the overall structure of the compiler; they are not owcharts and they do not specify module interfaces. INPUT OUTPUT Source text Target Code Error Reports

[1]  P Lucas,et al.  On the formal description of PL/I , 1969 .

[2]  Richard Edwin Stearns,et al.  Property Grammars and Table Machines , 1969, Inf. Control..

[3]  Laszlo A. Belady,et al.  A Study of Replacement Algorithms for Virtual-Storage Computer , 1966, IBM Syst. J..

[4]  Ursula Hill.  Special Run-Time Organization Techniques for Algol 68 , 1976, Compiler Construction.

[5]  William M. Waite,et al.  Implementing software for non-numeric applications , 1973 .

[6]  Isu Fang,et al.  FOLDS, a declarative formal language definition system , 1972 .

[7]  Fred J. Damerau,et al.  A technique for computer detection and correction of spelling errors , 1964, CACM.

[8]  C. A. R. Hoare,et al.  An Axiomatic Definition of the Programming Language PASCAL , 1973, Acta Informatica.

[9]  J. Bruno,et al.  The Generation of Optimal Code for Stack Machines , 1975, JACM.

[10]  David Gries,et al.  Compiler Construction for Digital Computers , 1971 .

[11]  Edgar T. Irons.  An error-correcting parse algorithm , 1963, CACM.

[12]  F. L. Deremer,et al.  Practical translators for LR(k) languages , 1969 .

[13]  Donald E. Knuth,et al.  An empirical study of FORTRAN programs , 1971, Softw. Pract. Exp..

[14]  John L. Bruno,et al.  Code Generation for a One-Register Machine , 1976, J. ACM.

[15]  Ralph E. Griswold,et al.  The Macro Implementation of SNOBOL4 , 1974 .

[16]  Raynard A. Hedberg.  Design of an Integrated Programming and Operating System Part III: The Expanded Function of the Loader , 1963, IBM Syst. J..

[17]  Peter C. Poole,et al.  A Mixed Code Approach , 1973, Comput. J..

[18]  Franklin L. DeRemer,et al.  Simple LR(k) grammars , 1971, Commun. ACM.

[19]  Robert Balzer,et al.  EXDAMS: extendable debugging and monitoring system , 1969, AFIPS '69 (Spring).

[20]  R. Stockton Gaines,et al.  The debugging of computer programs , 1969 .

[21]  Edgar T. Irons,et al.  Towards more versatile mechanical translators , 1963 .

[22]  Martin Richards.  The portability of the BCPL compiler , 1971, Softw. Pract. Exp..

[23]  David S. Johnson,et al.  The Complexity of Near-Optimal Graph Coloring , 1976, J. ACM.

[24]  John V. Guttag,et al.  Abstract data types and the development of data structures , 1976, Software Pioneers.

[25]  Stephen N. Zilles,et al.  Programming with abstract data types , 1974, SIGPLAN Symposium on Very High Level Languages.

[26]  Michael J. Fischer,et al.  An improved equivalence algorithm , 1964, CACM.

[27]  Richard J. W. Housden.  On String Concepts and Their Implementation , 1975, Comput. J..

[28]  Urs Ammann.  On code generation in a PASCAL compiler , 1976 .

[29]  Brian Randall,et al.  ALGOL 60 implementation , 1964 .

[30]  Daniel J. Rosenkrantz,et al.  Properties of deterministic top down grammars , 1969, STOC.

[31]  David W. Barron,et al.  Techniques for program error diagnosis on EDSAC 2 , 1963, Comput. J..

[32]  Urs Ammann.  Die Entwicklung eines PASCAL-Compilers nach der Methode des strukturierten Programmierens , 1975 .

[33]  F. Harary,et al.  The theory of graphs and its applications , 1963 .

[34]  Marvin Lowell Graham,et al.  An assembly language for reprogramming , 1965, CACM.

[35]  Mark B. Wells,et al.  Elements of Combinatorial Computing , 2014 .

[36]  Ken Kennedy,et al.  Automatic generation of efficient evaluators for attribute grammars , 1976, POPL.

[37]  Douglas T. Ross.  The AED free storage package , 1967, CACM.

[38]  Mehdi Jazayeri,et al.  Alternating semantic evaluator , 1975, ACM '75.

[39]  Cornelis H. A. Koster.  Using the CDL Compiler-Compiler , 1976, Compiler Construction.

[40]  Edward S. Lowry,et al.  Object code optimization , 1969, CACM.

[41]  William H. E. Day,et al.  Compiler Assignment of Data Items to Registers , 1970, IBM Syst. J..

[42]  Heinz Rutishauser,et al.  Automatische Rechenplanfertigung bei programmgesteuerten Rechenmaschinen , 1952 .

[43]  Hans Langmaack,et al.  Translation of Algol 60 , 1967 .

[44]  M. Griffiths,et al.  Relationship Between Definition and Implementation of a Language , 1972, Software Engineering.

[45]  Cliff B. Jones,et al.  Proving correctness of implementation techniques , 1971, Symposium on Semantics of Algorithmic Languages.

[46]  P. D. Stephens.  The IMP Language and Compiler , 1974, Comput. J..

[47]  Cornelis H. A. Koster,et al.  Error Reporting, Error Treatment, and Error Correction in Algol Translation - Part 1 , 1972, GI Jahrestagung.

[48]  Edgar T. Irons,et al.  A syntax directed compiler for ALGOL 60 , 1961, CACM.

[49]  Alfred V. Aho,et al.  Optimal Code Generation for Expression Trees , 1976, J. ACM.

[50]  W. M. Waite.  A sampling monitor for applications programs , 1973, Softw. Pract. Exp..

[51]  Jeffrey D. Ullman,et al.  The Generation of Optimal Code for Arithmetic Expressions , 1970, JACM.

[52]  William M. Waite,et al.  Semantic Analysis , 1976, International Conference on Compiler Construction.

[53]  Mark Elson,et al.  Code-Generation Technique for Large-Language Compilers , 1970, IBM Syst. J..

[54]  M. Donald MacLaren.  Data matching, data alignment, and structure mapping in PL/I , 1970, SIGP.

[55]  Ralph E. Griswold,et al.  The SNOBOL4 programming language , 1968 .

[56]  Rudolf Bayer,et al.  The ALCOR Illinois 7090/7094 post mortem dump , 1967, CACM.

[57]  Gregor von Bochmann,et al.  A (Truly) Usable and Portable Compiler Writing System , 1974, IFIP Congress.

[58]  Ben Wegbreit,et al.  A generalised compactifying garbage collector , 1972, Comput. J..