Vorlesung Compilertechnik Sommersemester 2009 Einführung M. Schölzel

Literatur A.V. Aho, J.D. Ullman: The Theory of Parsing, Translation, and Compiling – Volume I: Parsing. Prentice Hall, 1972, ISBN: 0-13-914556-7 . A.V. Aho, J.D. Ullman: The Theory of Parsing, Translation, and Compiling – Volume II: Compiling. Prentice Hall, 1973, ISBN: 0-13-914564-8. W.M. Waite, G. Goos: Compiler Construction. Springer Verlag, 1984, ISBN: 0-387-90821-8. R. Wilhelm, D. Maurer: Übersetzerbau – Theorie, Konstruktion, Generierung. Springer Verlag, 1992, ISBN:3-540-55704-0. A.V. Aho, M.S. Lam, R. Sethi, J.D. Ullman: Compilers – Principles, Techniques, & Tools, Second edition. Pearson Addison Wesley, 2007, ISBN: 0-321-48681-1. P. Bachmann: Mathematische Grundlagen der Informatik. Akademie Verlag, 1992, ISBN: 3-05-501242-5. D. Scheibler, M. Henke, P. Bachmann: Skript zur Compilertechnik. Vorlesungsskript, 2004.

Gegenseitige Abhängigkeiten Entwicklung der Compiler ist eng mit der Entwicklung der Programmiersprachen und Computerarchitekturen verbunden. Sprachen für Parallelrechner Computer- architektur Programmier- sprachen Native-Abarbeitung von Java-Bytecode (JOP) Behandelbaren Konstrukten, Vermeidung von schwer (z.B. Schlüsselworte als Bezeichner zulassen) Optimierungen Strukturierte Programmierung Deklarative Programmierung Objektorientierung Optimierung; Ausnutzung des CISC-Befehlssatzes Grenzen der statischen Compiler

Geschichte der Programmiersprachen (und Compiler) Imperative Programmiersprachen Objektorientierte Programmiersprachen Strukturierte Programmiersprachen Grace Hopper John Warner Backus Plankalkül von Zuse für ZR4; erst viel später praktisch umgesetzt 1972: PASCAL als konsequente Umsetzung eines strukturierten Programmierparadigmas C 1957: Fortran erster komerzieller Compiler für IBM 704 LISP, 1958, zur Implementierung von FORTRAN Unterprogrammen ALGOL-60: Erstmals Beschreibung der Syntax durch BNF Aufkommen von Assemblermnemonic 1952: Erster Compiler A-0 COBOL Simula 67, ergänzte Algol 60 um objektorientierte Konzepte: Klassen, Objekte, Koroutinen, Vererbung Smalltalk: rein objektorientiert James Gosling C Java Ken Thompson, Dennis Ritchie Erste Computer, Programmierung mit Binärcodes 1940 1950 1960 1970 1980 1990

Beispiel: FORTRAN I Anweisungen sind an festen Positionen auf der Lochkarte ausgerichtet Keine Subroutinen Keine geschachtelten Ausdrücke Speziell für die IBM 704 entwickelt Aus dem ersten Fortran Manual von 1956, gefunden auf: http://www.paulgraham.com/history.html

Beispiel: COBOL 004000-COMPUTE-PAYMENT. * MOVE 0 TO LW-LOAN-ERROR-FLAG. IF (LW-LOAN-AMT ZERO) OR (LW-INT-RATE ZERO) (LW-NBR-PMTS ZERO) MOVE 1 TO LW-LOAN-ERROR-FLAG GO TO 004000-EXIT. COMPUTE LW-INT-PMT = LW-INT-RATE / 1200 ON SIZE ERROR COMPUTE LW-PMT-AMT ROUNDED = (LW-LOAN-AMT * LW-INT-PMT) / (1 - 1.00000000 / ( (1 + LW-INT-PMT) ** LW-NBR-PMTS) ) COMPUTE LW-TOTAL-PMTS = LW-PMT-AMT * LW-NBR-PMTS COMPUTE LW-TOTAL-INT = LW-TOTAL-PMTS - LW-LOAN-AMT. 004000-EXIT. EXIT.

Meilenstein: Algol-60 Spezifikation der Syntax durch eine BNF Bedeutung von Schlüsselworten hängt nicht von ihrer Position ab (Prinzip der Formatfreiheit) Freie Zeileneinteilung: Weg vom festen Format der Lochkarten wie bei FORTRAN und COBOL Verwendung von Rutishausers Klammergebirgen zur Übersetzung von arithmetischen Formeln in Infixnotation (Bauer und Samelson) Aber: Erzwingt keine strukturierte Programmierung

Beispiel Algol-60 'BEGIN' 'COMENT' POLYGON: CALCULATES THE SIDES OF A POLYGON FOR Z POINTS IN R2 WITH X AND Y VALUES. (Z IS THE FIRST INPUT VALUE FOLLOWED BY PAIRS OF VALUES FOR INDIVIDUAL POINTS) PRINTS FOR EACH POINT THE FOLLOWING VALUES: NUMBER, X, Y, LENGTH OF SIDE, TOTAL LENGTH.; 'INTEGER' I, Z; 'REAL' X0, Y0, XA, Y,A, XN, YN, TL, L; READ(Z); READ(XA, YA); X0:= XA; Y0:= YA; I:= 0; L:= 0.0; NEW: READ(XN, YN); LAST: I:= I+1; TL:= SQRT((XN-XA)*(XN-XA) + (YN-YA)*(YN-YA)); L:= L+TL; PRINT(I, XA, YA, TL, L); XA:= XN; YA:= YN; 'IF' I 'LESS' Z-1 'THEN' 'GOTO' NEW; 'IF' I 'EQUAL' Z-1 'THEN' XN:= X0; YN:= Y0; 'GOTO' LAST; 'END'; 'END' POLYGON

Klassifizierung nach Generation Maschinensprache (kein Compiler erforderlich) 2. Generation Assemblersprachen (sehr einfache Übersetzung) 3. Generation Höhere Programmiersprachen (Fortran, LISP, C, Java, Haskell,…) (komplexe Compiler erforderlich) 4. Generation Anwendungsspezifische Sprachen (SQL) (relativ einfache Syntax; damit einfache Analyse; aber komplexe Verarbeitung) 5. Generation Logische und Constraint-basierte Programmiersprachen (Prolog) (relativ einfache Syntax; damit einfache Analyse; aber komplexe Verarbeitung)

Klassifizierung nach Programmierparadigma Imperative Programmiersprachen Das Programm spezifiziert eine Berechnungsvorschrift, also wie etwas zu berechnen ist (C, Java, …) Starke Orientierung an der Von-Neumann-Architektur Es wird grundsätzlich unterschieden zwischen: Anweisungen: Ändern den Zustand des Speichers oder steuern den Programmfluss Ausdrücke: Berechnen Werte auf Grundlage des aktuellen Speicherzustandes Deklarative Programmiersprachen Das Programm spezifiziert nur was zu berechnen ist (Prolog, [Haskell])

Fokus der Vorlesung Wir werden Techniken zur Entwicklung von Compilern für imperative (insbesondere strukturierte) Programmiersprachen der 3. Generation kennen lernen. Die dabei betrachteten Techniken zur Analyse des Quelltextes lassen sich auch zur Analyse von deklarativen Sprachen und Sprachen der 4. und 5. Generation nutzen. Lernziele: Prinzipien der Gestaltung von Compilern. Theoretische Grundlagen der lexikalischen und syntaktischen Analyse. Umgang mit und Verständnis von Scanner- und Parsergeneratoren. Prinzipien der Zielcodeerzeugung. Nach der Vorlesung sollten Sie in der Lage sein, einen einfachen Compiler selbst zu implementieren!

Gliederung (1) Einführung Grundlagen Formale Sprachen Grammatiken Entwurf kontextfreier Grammatiken Aufbau eines Compilers

Gliederung (2) Lexikalische Analyse Syntaktische Analyse Starkes LL(k) Schwaches LL(k) LR(k) Kontextprüfung (semantische Analyse) Zwischencodeerzeugung Zielcodeerzeugung Standardoptimierungen

Weiter zum Kapitel Grundlagen Ende der Einführung Weiter zum Kapitel Grundlagen

Rutishausers Klammergebirge Strukturierung vollständig geklammerter arithmetischer Ausdrücke zur Bestimmung einer Auswertungsreihenfolge: Aufwärtsstrich bei: ( und Operandensymbol Abwärtsstrich bei: ) und Operatorsymbol Beispiel: (((a:(b+c))-((d*e)*f))+g) Abarbeitung an der höchsten Stelle beginnen. c d e b ) ) + * a ( ) ( f ) : * ( - ( ) ( g ) + (

Rutishausers Klammergebirge – Abarbeitung c d e b ) ) + * a ( ) ( f ) : * ( - ( ) ( g ) + (

Rutishausers Klammergebirge – Abarbeitung d e ) * a ) ( f ) : t1 * ( - ( ) ( g ) + ( t1 = b + c

Rutishausers Klammergebirge – Abarbeitung ) f ) : t1 t2 * ( - ( ) ( g ) + ( t1 = b + c t2 = d * e

Rutishausers Klammergebirge – Abarbeitung f ) t2 * t3 - ( ) ( g ) + ( t1 = b + c t2 = d * e t3 = a : t1

Rutishausers Klammergebirge – Abarbeitung - ) t4 ( g ) + ( t1 = b + c t2 = d * e t3 = a : t1 t4 = t2 * f

Rutishausers Klammergebirge – Abarbeitung ) + ( t1 = b + c t2 = d * e t3 = a : t1 t4 = t2 * f t5 = t3 - t4

Rutishausers Klammergebirge – Abarbeitung t1 = b + c t2 = d * e t3 = a : t1 t4 = t2 * f t5 = t3 - t4 t6 = t5 + g

Bauer/Samelson – Erfindung des Kellerprinzips Keller speichert noch nicht ausgewertete Präfixe: Einstapeln bis eine schließende Klammer erreicht Suchen der zugehörigen öffnenden Klammer im Stapel und Auswerten der geklammerten Operation und Einstapeln des berechneten Wertes Abarbeitungsreihenfolge entspricht der Auswertung des am weitesten links stehenden lokalen Maximum im Klammergebirge. Beispiel: (((a:(b+c))-((d*e)*f))+g) Stapel Eingabe Ausgabe (((a:(b+c ))-((d*e)*f))+g) (((a:t1 )-((d*e)*f))+g) t1 = b + c ((t2 -((d*e)*f))+g) t2 = a : t1 ((t2-((d*e )*f))+g) ((t2-(t3 *f))+g) t3 = d*e ((t2-(t3*f ))+g) ((t2-t4 )+g) t4 = t3*f (t5 +g) t5 = t2-t4 (t5+g ) t6 t6 = t5+g

Bauer/Samelson – Erfindung des Kellerprinzips Auf vollständige Klammerung kann verzichtet werden, trotzdem Beachtung von Prioritäten der Operatoren, wenn außerdem: ein Operator nur dann eingestapelt wird, wenn der am weitesten oben liegende Operator im Keller eine niedrigere Priorität hat oder nach der letzten öffnenden Klammer im Stapel kein Operator eingestapelt wurde. Ansonsten wird der Operator im Keller ausgewertet Beispiel: ((a:(b+c))-d*e*f+g) Stapel Eingabe Ausgabe ((a:(b+c ))-d*e*f+g) ((a:t1 )-d*e*f+g) t1 = b + c (t2 -d*e*f+g) t2 = a : t1 (t2-d*e *f+g) (t2-t3 *f+g) t3 = d*e (t2-t3*f +g) (t2-t4 +g) t4 = t3*f (t5 +g) t5 = t2-t4 (t5+g ) t6 t6 = t5+g zurück