vorlesung compilertechnik sommersemester 2009 einführung m. schölzel
TRANSCRIPT
![Page 1: Vorlesung Compilertechnik Sommersemester 2009 Einführung M. Schölzel](https://reader036.vdocuments.us/reader036/viewer/2022070310/55204d6149795902118b46ab/html5/thumbnails/1.jpg)
Vorlesung CompilertechnikSommersemester 2009
Einführung
M. Schölzel
![Page 2: Vorlesung Compilertechnik Sommersemester 2009 Einführung M. Schölzel](https://reader036.vdocuments.us/reader036/viewer/2022070310/55204d6149795902118b46ab/html5/thumbnails/2.jpg)
2
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.
![Page 3: Vorlesung Compilertechnik Sommersemester 2009 Einführung M. Schölzel](https://reader036.vdocuments.us/reader036/viewer/2022070310/55204d6149795902118b46ab/html5/thumbnails/3.jpg)
3
Gegenseitige Abhängigkeiten
Computer-architektur
Programmier-sprachen
CompilerSt
rukt
urie
rte P
rogr
amm
ieru
ng
Obj
ekto
rient
ieru
ng
Dek
lara
tive
Prog
ram
mie
rung
Native-Abarbeitung vonJava-Bytecode (JOP)
Ver
mei
dung
von
sch
wer
Beh
ande
lbar
en K
onst
rukt
en,
(z.B
. Sch
lüss
elw
orte
als
Bez
eich
ner z
ulas
sen)
Optim
ierungenGrenzen der statischen
Optim
ierung; Ausnutzung des CISC
-Befehlssatzes
Sprachen für Parallelrechner
Entwicklung der Compiler ist eng mit der Entwicklung der Programmiersprachen und Computerarchitekturen verbunden.
![Page 4: Vorlesung Compilertechnik Sommersemester 2009 Einführung M. Schölzel](https://reader036.vdocuments.us/reader036/viewer/2022070310/55204d6149795902118b46ab/html5/thumbnails/4.jpg)
4
Geschichte der Programmiersprachen (und Compiler)
1940
Ers
te C
om
pute
r,
Pro
gra
mm
ieru
ng
mit
Bin
ärc
odes
1950 1960 1970 1980 1990
Aufk
om
men v
on A
ssem
ble
rmnem
onic
19
57
: Fort
ran e
rste
r kom
erz
ielle
r C
om
pile
r fü
r IB
M 7
04
CO
BO
L
LISP,
19
58
, zu
r Im
ple
menti
eru
ng v
on
FO
RTR
AN
Unte
rpro
gra
mm
en
Sim
ula
67
, erg
änzt
e A
lgol 6
0 u
m
obje
ktori
enti
ert
e K
onze
pte
: K
lass
en,
Obje
kte
, K
oro
uti
nen,
Vere
rbung
Sm
allt
alk
: re
in o
bje
kto
rienti
ert
Imperative Programmiersprachen
Strukturierte ProgrammiersprachenObjektorientierte Programmiersprachen
C19
72
: PA
SC
AL
als
konse
quente
U
mse
tzung e
ines
stru
kturi
ert
en
Pro
gra
mm
ierp
ara
dig
ma
s
C
Pla
nkalk
ül von
Zuse
für
ZR
4;
ers
t vie
l sp
äte
r pra
ktis
ch
um
gese
tzt
ALG
OL-
60
: Ers
tmals
Besc
hre
ibung d
er
Synta
x d
urc
h B
NF
Java
Ken Thompson, Dennis Ritchie James Gosling
John Warner Backus
19
52
: Ers
ter
Com
pile
r A
-0Grace Hopper
![Page 5: Vorlesung Compilertechnik Sommersemester 2009 Einführung M. Schölzel](https://reader036.vdocuments.us/reader036/viewer/2022070310/55204d6149795902118b46ab/html5/thumbnails/5.jpg)
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: http://www.paulgraham.com/history.html
![Page 6: Vorlesung Compilertechnik Sommersemester 2009 Einführung M. Schölzel](https://reader036.vdocuments.us/reader036/viewer/2022070310/55204d6149795902118b46ab/html5/thumbnails/6.jpg)
6
Beispiel: COBOL
004000-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 004000-EXIT. * COMPUTE LW-INT-PMT = LW-INT-RATE / 1200 ON SIZE ERROR MOVE 1 TO LW-LOAN-ERROR-FLAG GO TO 004000-EXIT. * COMPUTE LW-PMT-AMT ROUNDED = (LW-LOAN-AMT * LW-INT-PMT) / (1 - 1.00000000 / ( (1 + LW-INT-PMT) ** LW-NBR-PMTS) ) ON SIZE ERROR MOVE 1 TO LW-LOAN-ERROR-FLAG GO TO 004000-EXIT. * COMPUTE LW-TOTAL-PMTS = LW-PMT-AMT * LW-NBR-PMTS ON SIZE ERROR MOVE 1 TO LW-LOAN-ERROR-FLAG GO TO 004000-EXIT. * COMPUTE LW-TOTAL-INT = LW-TOTAL-PMTS - LW-LOAN-AMT. * 004000-EXIT. EXIT.
![Page 7: Vorlesung Compilertechnik Sommersemester 2009 Einführung M. Schölzel](https://reader036.vdocuments.us/reader036/viewer/2022070310/55204d6149795902118b46ab/html5/thumbnails/7.jpg)
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)
Aber: Erzwingt keine strukturierte Programmierung
![Page 8: Vorlesung Compilertechnik Sommersemester 2009 Einführung M. Schölzel](https://reader036.vdocuments.us/reader036/viewer/2022070310/55204d6149795902118b46ab/html5/thumbnails/8.jpg)
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
![Page 9: Vorlesung Compilertechnik Sommersemester 2009 Einführung M. Schölzel](https://reader036.vdocuments.us/reader036/viewer/2022070310/55204d6149795902118b46ab/html5/thumbnails/9.jpg)
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)
![Page 10: Vorlesung Compilertechnik Sommersemester 2009 Einführung M. Schölzel](https://reader036.vdocuments.us/reader036/viewer/2022070310/55204d6149795902118b46ab/html5/thumbnails/10.jpg)
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])
![Page 11: Vorlesung Compilertechnik Sommersemester 2009 Einführung M. Schölzel](https://reader036.vdocuments.us/reader036/viewer/2022070310/55204d6149795902118b46ab/html5/thumbnails/11.jpg)
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!
![Page 12: Vorlesung Compilertechnik Sommersemester 2009 Einführung M. Schölzel](https://reader036.vdocuments.us/reader036/viewer/2022070310/55204d6149795902118b46ab/html5/thumbnails/12.jpg)
12
Gliederung (1)
1. Einführung2. Grundlagen
1. Formale Sprachen2. Grammatiken3. Entwurf kontextfreier Grammatiken4. Aufbau eines Compilers
![Page 13: Vorlesung Compilertechnik Sommersemester 2009 Einführung M. Schölzel](https://reader036.vdocuments.us/reader036/viewer/2022070310/55204d6149795902118b46ab/html5/thumbnails/13.jpg)
13
Gliederung (2)
3. Lexikalische Analyse4. Syntaktische Analyse
1. Starkes LL(k)2. Schwaches LL(k)3. LR(k)
5. Kontextprüfung (semantische Analyse)6. Zwischencodeerzeugung7. Zielcodeerzeugung8. Standardoptimierungen
![Page 14: Vorlesung Compilertechnik Sommersemester 2009 Einführung M. Schölzel](https://reader036.vdocuments.us/reader036/viewer/2022070310/55204d6149795902118b46ab/html5/thumbnails/14.jpg)
Ende der Einführung
Weiter zum Kapitel Grundlagen
![Page 15: Vorlesung Compilertechnik Sommersemester 2009 Einführung M. Schölzel](https://reader036.vdocuments.us/reader036/viewer/2022070310/55204d6149795902118b46ab/html5/thumbnails/15.jpg)
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:
(
cb + ))
-(
(
d e* )
))
+g )
*f
![Page 16: Vorlesung Compilertechnik Sommersemester 2009 Einführung M. Schölzel](https://reader036.vdocuments.us/reader036/viewer/2022070310/55204d6149795902118b46ab/html5/thumbnails/16.jpg)
16
Rutishausers Klammergebirge – Abarbeitung
(
(
(
a:
(
cb + ))
-(
(
d e* )
))
+g )
*f
![Page 17: Vorlesung Compilertechnik Sommersemester 2009 Einführung M. Schölzel](https://reader036.vdocuments.us/reader036/viewer/2022070310/55204d6149795902118b46ab/html5/thumbnails/17.jpg)
17
Rutishausers Klammergebirge – Abarbeitung
(
(
(
a: t1
)
-(
(
d e* )
*f )
)
+g )
t1 = b + c
![Page 18: Vorlesung Compilertechnik Sommersemester 2009 Einführung M. Schölzel](https://reader036.vdocuments.us/reader036/viewer/2022070310/55204d6149795902118b46ab/html5/thumbnails/18.jpg)
18
Rutishausers Klammergebirge – Abarbeitung
(
(
(
a: t1
)
-(t2 *
f ))
+g )
t1 = b + c
t2 = d * e
![Page 19: Vorlesung Compilertechnik Sommersemester 2009 Einführung M. Schölzel](https://reader036.vdocuments.us/reader036/viewer/2022070310/55204d6149795902118b46ab/html5/thumbnails/19.jpg)
19
Rutishausers Klammergebirge – Abarbeitung
(
(
t3 -(t2 *
f ))
+g )
t1 = b + c
t2 = d * e
t3 = a : t1
![Page 20: Vorlesung Compilertechnik Sommersemester 2009 Einführung M. Schölzel](https://reader036.vdocuments.us/reader036/viewer/2022070310/55204d6149795902118b46ab/html5/thumbnails/20.jpg)
20
Rutishausers Klammergebirge – Abarbeitung
(
(
t3 -t4
)
+g )
t1 = b + c
t2 = d * e
t3 = a : t1
t4 = t2 * f
![Page 21: Vorlesung Compilertechnik Sommersemester 2009 Einführung M. Schölzel](https://reader036.vdocuments.us/reader036/viewer/2022070310/55204d6149795902118b46ab/html5/thumbnails/21.jpg)
21
Rutishausers Klammergebirge – Abarbeitung
(
t5+
g )
t1 = b + c
t2 = d * e
t3 = a : t1
t4 = t2 * f
t5 = t3 - t4
![Page 22: Vorlesung Compilertechnik Sommersemester 2009 Einführung M. Schölzel](https://reader036.vdocuments.us/reader036/viewer/2022070310/55204d6149795902118b46ab/html5/thumbnails/22.jpg)
22
Rutishausers Klammergebirge – Abarbeitung
t6
t1 = b + c
t2 = d * e
t3 = a : t1
t4 = t2 * f
t5 = t3 - t4
t6 = t5 + g
![Page 23: Vorlesung Compilertechnik Sommersemester 2009 Einführung M. Schölzel](https://reader036.vdocuments.us/reader036/viewer/2022070310/55204d6149795902118b46ab/html5/thumbnails/23.jpg)
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)
Stapel Eingabe
(((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
Ausgabe
![Page 24: Vorlesung Compilertechnik Sommersemester 2009 Einführung M. Schölzel](https://reader036.vdocuments.us/reader036/viewer/2022070310/55204d6149795902118b46ab/html5/thumbnails/24.jpg)
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)
Stapel Eingabe
((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
Ausgabe
zurück