Die Präsentation wird geladen. Bitte warten

Die Präsentation wird geladen. Bitte warten

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

Ähnliche Präsentationen


Präsentation zum Thema: "Vorlesung Compilertechnik Sommersemester 2009 Einführung M. Schölzel."—  Präsentation transkript:

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

2 2 Literatur A.V. Aho, J.D. Ullman: The Theory of Parsing, Translation, and Compiling – Volume I: Parsing. Prentice Hall, 1972, ISBN: A.V. Aho, J.D. Ullman: The Theory of Parsing, Translation, and Compiling – Volume II: Compiling. Prentice Hall, 1973, ISBN: W.M. Waite, G. Goos: Compiler Construction. Springer Verlag, 1984, ISBN: R. Wilhelm, D. Maurer: Übersetzerbau – Theorie, Konstruktion, Generierung. Springer Verlag, 1992, ISBN: A.V. Aho, M.S. Lam, R. Sethi, J.D. Ullman: Compilers – Principles, Techniques, & Tools, Second edition. Pearson Addison Wesley, 2007, ISBN: P. Bachmann: Mathematische Grundlagen der Informatik. Akademie Verlag, 1992, ISBN: D. Scheibler, M. Henke, P. Bachmann: Skript zur Compilertechnik. Vorlesungsskript, 2004.

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

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

5 5 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:

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

7 7 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)Rutishausers Klammergebirgen Aber: Erzwingt keine strukturierte Programmierung

8 8 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' 'BEGIN' XN:= X0; YN:= Y0; 'GOTO' LAST; 'END'; 'END' POLYGON

9 9 Klassifizierung nach Generation 1. 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)

10 10 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])

11 11 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!

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

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

14 Ende der Einführung Weiter zum Kapitel GrundlagenGrundlagen

15 15 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. ( ( ( a : ( c b + ) ) - ( ( d e * ) ) ) + g ) * f

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

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

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

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

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

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

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

23 23 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) StapelEingabe (((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) t6t6 = t5+g Ausgabe

24 24 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) StapelEingabe ((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) t6t6 = t5+g Ausgabe zurück


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

Ähnliche Präsentationen


Google-Anzeigen