Grundlagen der Informatik. Prof. Dr. Stefan Enderle NTA Isny

Transkript

1 Grundlagen der Informatik Prof. Dr. Stefan Enderle NTA Isny

2 5 Compilerbau

3 5.1 Einführung Ein Compiler (Übersetzer) ist ein Computerprogramm, das ein in einer Quellsprache geschriebenes Programm (Quellprogramm) in ein semantisch äquivalentes Programm einer Zielsprache (Zielprogramm) umwandelt. Normalerweise: Quellprogramm: Computerprogramm in einer Programmiersprache Zielprogramm: Maschinensprache-Programm einer bestimmten CPU Compilerbau ist eine Disziplin innerhalb der Praktischen Informatik

4 Compiler-Phasen Frontend: Backend:

5 Frontend Lexikalische Analyse: Scanner (Lexer) unterteilt Programmtext in Token. Syntaktische Analyse: Parser prüft korrekte Syntax und erzeugt Syntaxbaum. Gibt ggfs. Syntaxfehler aus. Semantische Analyse: Prüfung der Semantik, also weitere Bedingungen (Variablen deklariert? Typen korrekt?...) attributierter Syntaxbaum

6 Backend Zwischencodeerzeugung: Übersetzen des Syntaxbaums in Zwischencode (für verschiedene Zielplattformen verwendbar) Programmoptimierung: Optimierungen auf Basis des Zwischencodes. Codegenerierung: Erzeugen des ausführbaren Programms in Maschinensprache (Objektdatei für späteres Linken)

7 Vergleich: Interpreter Ein Interpreter liest den Quellcode ein, analysiert ihn und führt ihn direkt aus. Analyse des Quellcodes erfolgt zur Laufzeit des Programms. Nachteil: Geschwindigkeit Interpretersprachen: BASIC, Perl, Ruby, PHP, Javascript Sprachen mit Bytecode (Compiler+Interpreter): Java, C#, Perl, Python.

8 Programmtext Ein Programm ist ein Text, d.h. Folge von Zeichen Erste Programmiersprachen: Nur Großbuchstaben, Klammern, Ziffern Pascal, C: Auch Kleinbuchstaben, Sonderzeichen + - < > Java: Unicode (z.b. auch ä ö ü)

9 Programmtext Die erlaubten Zeichen nennt man Alphabet. Erlaubte Wörter der Sprache: Schlüsselwörter (while, do, if, for else,...) Sonderzeichen (+, -, *, <, >, <=, >=,...) Bezeichner (testfunktion, betrag, x37,...) Konstanten (42, -1, 3.141,...)

10 5.2 Lexikalische Analyse Scanner: Input: String mit Programmtext Output: Folge von Token Token (eigentlich Gutschein ): Gleiche Token für gleichartige Wörter Beispiele: Für jede Zahl: num Für jeden Bezeichner: id Für Strings: str Für Sonderzeichen: eq (=), gt (>), assingop (=) Für Schlüsselwörter: begin, while, do,...

11 Lexikalische Analyse Bildlich:

12 Lexikalische Analyse Beispiel (Pascal):

13 Lexikalische Analyse Probleme: Sind begin, BeGiN, BEGIN dasselbe? Ist beginnen ein Bezeichner (id) oder Schlüsselwort begin und Bezeichner nen Sind 00.23e-001 oder 312.e-2 vom Typ num Heutiger Ansatz: Beschreibung der Token als reguläre Ausdrücke Automatisches Generieren eines Scanners durch Hilfsprogramm (z.b. flex)

14 Token als reg. Ausdrücke Beispiele: Ziffer Ganzzahl Bezeichner Filename Ziffer Stunde [0-9] [0-9]+ [_a-za-z][a-za-z0-9]* [a-za-z0-9\/.-]+ [0-9] [01][0-9] 2[0-3]

15 flex Freie Variante von lex (frühes UNIX) Funktion Eingabe: Datei mit regulären Ausdrücken Ausgabe: C-Programm mit Scanner für die definierten Ausdrücke Varianten für Pascal, Perl, Java,... Intern: flex erzeugt endliche Automaten und minimiert diese Das erzeugte Programm liest von stdin und sucht den passenden Automaten Bei match wird definierte Ausgabe erzeugt

16 flex - Eingabedatei Beispiel: Finden aller Zeitangaben in beliebigem Text Bei Fund, ausgeben der Zeit Zeit-Format: 12:35 05:00 23:59:30 flex Eingabedatei: ASCII-Datei mit 3 Abschnitten, Trennung der Abschnitte durch %% Definition von regulären Ausdrücken Pro reg. Ausdruck eine Aktion (C-Code) Einbettung von yylex() in Hauptprogramm

17 flex - Eingabedatei

18 flex - Scannergenerierung flex zeit.lex gcc -ll > zeit.exe Übersetzen von zeit.lex nach zeit.c durch flex Übersetzen von zeit.c nach zeit.exe durch gcc

19 5.3 Syntaxanalyse Parser: Input: Folge von Token Output: (Vorerst) ja/nein : Ist die Token-Folge ein zulässiges Wort der Sprache / Entspricht die Token-Folge der Syntax/Grammatik. Grammatik: Wir kennen einige Grammatik-Typen: Reguläre Grammatiken Kontextfreie Grammatiken Wir benötigen z.b. Klammern => Kontextfreie Grammatik

20 Grammatik (Wdh.) Definition: Grammatik Eine Grammatik ist ein Tupel G=(Σ, N, P, S) mit Σ = Terminal-Alphabet N = Nonterminal-Alphabet P = Produktionenmenge (Regelmenge) S = Startsymbol

21 Kontextfreie Grammatik (Wdh.) Definition: Kontextfreie Grammatik Eine Grammatik G=(Σ, N, P, S) heißt kontextfrei, falls die Regelmenge P N (Σ N)* mit P < ist.

22 Ableitung (Wdh.) Eine Ableitung beschreibt, wie man vom Startsymbol zu einem Wort der Sprache L kommt. Ein Ableitungsschritt ist hierbei die Ersetzung eines Nichtterminalsymboles durch eines oder mehrere Terminal- oder Nichtterminalsymbole. Die Ableitung endet, wenn keine Nichtterminalsymbole mehr auftreten.

23 Beispiel (Wdh.) G = ({a,b,c}, {S,A,B}, P, S} mit P = { S AB, A ab, B c} Die Sprache L(G) enthält nur ein Wort: S AB abb abc S AB Ac abc (2 Ableitungen)

24 Beispiel (Wdh.) Gesucht: Grammatik, die gleich viele a's wie b's produziert. Teste: G = ({a,b}, {S}, P, S} mit P = { S asb } S asb aasbb aaasbbb... Zur Terminierung: S ε Also: G = ({a,b}, {S}, { S asb, S ε }, S} bzw. G = ({a,b}, {S}, { S asb ε }, S}

25 Beispiel (Wdh.) Grammatik für Klammer-Ausdrücke Regelmenge P = { E a EOE (E), O + - * / } Ableitung: E EOE aoe a+e a+a E EOE aoe a+e a+(e) a+(eoe) a+(aoe) a+(a-e) a+(a-a)

26 Grammatik WHILE Beispiel einer Grammatik für die Sprache WHILE

27 Grammatik WHILE Terminale = { begin, end, ;, id, :=, while, do, if, then, +, -, *, (, ), =, <, num, not, true, false } Nichtterminale = { Programm, Anweisungen, Anweisung, Zuweisung, Schleife, Alternative, Expr, Bexpr } Startsymbol = Programm

28 WHILE Ableitungen Einfachste Ableitung: Programm begin Anweisungen end begin end

29 WHILE Ableitungen Der Parser soll prüfen, ob ein Wort (also ein Programm) ableitbar ist: begin id:=num; end Programm begin Anweisungen end begin Anweisung; Anweisungen end begin Zuweisung; Anweisungen end begin id:=expr; Anweisungen end begin id:=num; Anweisungen end begin id:=num; end

30 WHILE Ableitungen Linksableitung: Wird (wie im Beispiel) immer zuerst das am weitesten links stehende Nichtterminal ersetzt, sagen wir zu der Ableitung Linksableitung

31 Beispiel (Wdh.) Je nachdem, welche Regel man wählt, ergeben sich z.t. unterschiedliche Ableitungsbäume: E EOE aoe a*e a*eoe a*aoe a*a+e a*a+a E EOE EOEOE aoeoe a*eoe a*aoe a*a+e a*a+a E E E O E E O E a * E O E E O E + a falsch a + a a Punkt * a vor Strich

32 Eindeutige Grammatiken Für Programmiersprachen und deren Parser sind mehrdeutige Grammatiken ungeeignet. Man beschränkt sich daher in der Praxis auf eindeutige Grammatiken. Beispiel: Anstatt der einen Regel Expr :: Expr+Expr Expr-Expr Expr*Expr (Expr) id num führen wir neue Nichtterminale ein, die die Priorität ausdrücken: Expr :: Expr+Term Expr-Term Term Term :: Term*Faktor Faktor Faktor :: id num (Expr)

33 Eindeutige Grammatiken Expr Ableitungsbaum für id*id+id Expr + Term Regelmenge: Expr :: Expr+Term Expr-Term Term Term Term :: Term*Faktor Faktor Faktor Faktor :: id num (Expr) Term * Faktor id Faktor id id

34 Termbaum (abstrakter Syntaxbaum) Expr Beim Termbaum wandern die Terminalsymbole nach oben und ersetzen die Nichtterminale Expr + Term Term Faktor + Term * * id Faktor id Faktor id id id id

35 Beispiel * Termbaum für id*(((id-id)/id)-((id+id)*id)) id -- / - id * id id + id id id

36 Recursive Descent Parser Nochmals allgemein: Parser: Input: Folge von Token Output: (Vorerst) ja/nein : Ist die Token-Folge ein zulässiges Wort der Sprache / Entspricht die Token-Folge der Syntax/Grammatik. Wie lässt sich solch ein Parser implementieren? Einfachster Ansatz: Recursive Descent Parser (RD-Parser)

37 Recursive Descent Parser Beispiel mit einer einzigen Regel: Schleife :: while Bexpr do Anweisung Um eine Schleife zu akzeptieren akzeptiere ein while erkenne eine Bexpr akzeptiere ein do erkenne eine Anweisung

38 Recursive Descent Parser Um eine Schleife zu akzeptieren akzeptiere ein while erkenne eine Bexpr akzeptiere ein do erkenne eine Anweisung Direkte Umsetzung als Funktion: void parseschleife() { akzeptiere( while ); parsebexpr(); akzeptiere( do ); parseanweisung(); }

39 Recursive Descent Parser Problem, wenn es mehrere rechte Seiten gibt: Anweisung :: Zuweisung Schleife Alternative Umsetzung mit MAGIC ODER (Nichtdeterminismus): void parseanweisung() { parsezuweisung(); ODER parseschleife(); ODER parsealternative(); }

40 Recursive Descent Parser Wenn wir wenigstens um EIN Token vorausschauen könnten, könnten wir vielleicht entscheiden, welchen Zweig das MAGIC ODER auswählen muss => lookahead Umsetzung mit Lookahead: void parseanweisung() { if (l==id) parsezuweisung(); else if (l==while) parseschleife(); else if (l==if) parsealternative(); } else print ( id, while, if erwartet );

41 LL(1) Grammatiken Ein Recursive Descent Parser hat dann ein Problem, wenn eine Regel mehrere rechte Seiten besitzt: Anweisung :: Zuweisung Schleife Alternative Vorausschau um EIN Token ist nötig (falls EIN Token ausreicht...)

42 LL(1) Grammatiken LL(1) Grammatik (informell): Ist es für die gesamte Grammatik möglich, aufgrund der Vorausschau von nur einem Token immer zu entscheiden, welche Regel gewählt werden muss, so spricht man von einer LL(1) Grammatik.

43 LL(1) Grammatiken Formaler: Geg. eine Regel: A :: α α... α 1 2 n Vorausschau eindeutig, falls jedes αi mit einem unterschiedlichen Token ti beginnt. (bisher noch ohne ε)

44 LL(1) Grammatiken Sei First(A) die Menge aller Token, mit denen ein aus A abgeleitetes Wort beginnen kann: First(A) = { First(αi) i=1...n} Wenn gilt First(αi) First(αj) = Ø für alle i,j, dann kann der Nichtdeterminismus eindeutig aufgelöst werden.

45 LL(1) Grammatiken Beispiel: Anweisung :: Zuweisung Schleife Alternative First(Zuweisung) = { id } First(Schleife) = { if } First(Alternative) = { while } also First(Anweisung) = { id, if, while } Und es gilt: First(αi) First(αj) = Ø für alle i,j

46 LL(1) Grammatiken Aus First(Zuweisung) = { id } First(Schleife) = { if } First(Alternative) = { while } folgt dann der Parser für <Anweisung>: void parseanweisung() { if (l==id) parsezuweisung(); else if (l==while) parseschleife(); else if (l==if) parsealternative(); } else print ( id, while, if erwartet );

47 LL(1) Grammatiken Weiteres Problem: Optionale Regel (ε) Anweisungen :: ε Anweisung Anweisung; Anweisungen Wir wissen noch: First(Anweisung) = { id, if, while } Aber First(Anweisungen) enthält auch ε : First(Anweisungen) = { id, if, while } { ε }

48 LL(1) Grammatiken Allgemeine Definition für First(A): First(A) = { t A * tα } { ε A * ε }

49 LL(1) Grammatiken Für den Parser von Anweisungen :: ε Anweisung Anweisung; Anweisungen wird wieder ein MAGIC ODER benötigt: void parseanweisungen() { return; ODER parseanweisung(); ODER parseanweisung(); parseanweisungen(); }

50 LL(1) Grammatiken bzw. mit Optimierung: Anweisungen :: ε Anweisung Anweisung; Anweisungen void parseanweisungen() { return; ODER parseanweisung(); parseanweisungen(); } ODER muss (durch Vorausschau) entscheiden, ob eine Anweisung folgt oder nicht!

51 LL(1) Grammatiken Annahme: Es ist bekannt, welches Token NACH einer Regel kommen kann: In WHILE kann nach <Anweisungen> nur end kommen! Also: void parseanweisungen() { if (l==end) return; else if (l==id l==if l==while) parseanweisung(); parseanweisungen(); else print ( id, while, if, end erwartet ); }

52 LL(1) Grammatiken Sei Follow(A) die Menge aller Token, die in einer Grammatik auf A folgen können: Follow(A) = { t S * αatβ } Beispiele für WHILE: Follow(Anweisungen) = { end } Follow(Anweisung) = { ;, end } = { ;, +, -, *, ), = } Follow(Expr)

53 LL(1) Grammatiken Berechnung von First(α) für alle rechten Seiten α: 1.Für jedes Token t, für das gilt: α = tγ Setze First(α) { t } 2.Für jedes Nichtterminal B mit α = Bγ Für alle B β : First(α) First(α) - { ε } Falls noch B * ε : First(α) First(γ) Falls noch α * ε : First(α) ε

54 LL(1) Grammatiken Berechnung von Follow(A) für alle Nichtterminale A: (Sei eof das Ende des Inputs) 1. Follow(S) eof 2. Für jede Regel A αxβ Follow(X) First(β) - { ε } Falls β * ε : Follow(X) Follow(A)

55 LL(1) Grammatiken LL(1) Grammatik (formal): Eine Grammatik G heißt LL(1), falls für jede Regel A :: α1 α2... αn und alle i j folgende Bedingungen erfüllt sind: 1. First(αi) First(αj) = Ø 2. ε First(αi) Follow(A) First(αj) = Ø

56 LL(1) Grammatiken Für LL(1) Grammatiken lassen sich leicht Recursivdescent Parser erstellen. Falls gilt: { f=frage zum Thema offen(f) } = Ø dann folgt Schöne Ferien!

57 Wdh: Grammatik WHILE Beispiel einer Grammatik für die Sprache WHILE

58 Top-Down Parsing Recursive-Descent Parser sind Top-Down Parser : Start mit dem Startsymbol (Wurzel) S Unter Zuhilfenahme des Look-ahead entsprechende Erweiterung: A α1 α2... αn

59 Top-Down Parsing Beispiel in WHILE

60 Shift-Reduce Parser Shift-Reduce Parser sind schwieriger zu implementieren als Recursive-Descent Parser Vorteile: Grammatik muss nicht LL(1) sein Syntaxbaum kann leicht mit erstellt werden Es existieren Werkzeuge für die automatische Erstellung

61 Shift-Reduce Parser Notation: sei α bereits im Input gelesen und erkannt, nächstes Token sei a restliches Eingabewort sei u α au

62 Shift-Reduce Parser Arbeitsweise: Ein SR-Parser versucht immer die rechte Seite einer Regel im bisherigen Input zu erkennen, diese zur linken Seite zu reduzieren. Er kann zwei mögliche Aktionen ausführen: Shift: Das nächste Zeichen im Input lesen und in neuen Zustand übergehen: α au αa u Ein Endstück α2 von α als rechte Seite Reduce: einer Regel A α erkenne und ersetzen: α1α2 au α1a u

63 Shift-Reduce Parser Ablauf: Start mit gesamten Eingabewort w, also w Ende im Starzustand S, also S Beispiel: Grammatik: Expr :: Expr+Term Expr-Term Term Term :: Term*Faktor Faktor Faktor :: id num (Expr) Eingabewort w = x*(y+1) also Token: id * ( id + num )

64 Shift-Reduce Parser

65 Bottom-Up Parsing Shift-Reduce Parser sind Bottom-Up Parser : Start mit den einzelnen Token Sukzessives Zusammenbauen bis zur Wurzel S

66 Bottom-Up Parsing Beispiel in WHILE

67 Shift-Reduce Parser Konflikte: Grammatik: Expr :: Expr+Term Expr-Term Term Term :: Term*Faktor Faktor Faktor :: id num (Expr) Shift-Reduce-Konflikt: Aktueller Zustand: T*(E+num ) Shift: T*(E+num) Reduce: T*(E+F ) Reduce-Reduce-Konflikt: Aktueller Zustand: T*(E+T ) Reduce 1: T*(E+E ) (mit E T) Reduce 2: T*(E ) (mit E E+T)

68 LR(1) Grammatiken LR(1) Grammatik (informell): Eine Grammatik heißt LR(1) Grammatik, wenn es möglich ist, anhand der Vorausschau von nur einem Token, immer zu entscheiden, welche Aktion gewählt werden muss.

69 Parsergeneratoren Parsergeneratoren konstruieren einen Parser aus einer kontextfreien Grammatik. Bekanntester Parsergenerator: lex / yacc (flex / bison) Anderes Beispiel: javacc für Recursive-Descent-Parser oder jflex für Shift-Reduce-Parser

70 Bison Idee: Input = ASCII File mit Grammatik Output = C-Code eines fertigen Parses Beispiel: %token ID %% S : T T : T '*' F F ; F : '(' T ')' ID ; %%

71 Bison Der endliche Automat, den Bison intern produziert, lässt sich ausgeben: state 0 ID shift, and go to state '(' shift, and go to state S go to state 9 state 1 F -> ID. (rule 5) $default reduce using rule state 2 F -> '('. T ')' (rule 4) ID shift, and go to state '(' shift, and go to state T go to state 5 4 go to state (F) 1 2

72 Flex / Bison Ablauf der Implementierung

73 Flex / Bison Ablauf des Parsens

74 Fehlererkennung Fehler können vom Scanner oder Parser erkannt werden: Fehlererkennung durch Scanner: Lesen von Zeichenfolgen, die sich nicht zu gültigen Token gruppieren lassen. Beispiel: oder!? Token Invalid, mit Zeile und Spalte

75 Fehlererkennung Fehlererkennung durch Parser: Lesen einer Tokenfolge, die nicht zur Grammatik passt. Beispiel: Zuweisung :: id=expr Tokenfolge: id = while... Abhilfe direkt in Parser-Regeln: Beispiel: yacc/bison: zuweisung : ID = expr ID = { err( expr expected );} ID { err( = expected );}

76 Fehlererkennung Fehlererkennung durch Parser: Problem: Findet der Parser einen Fehler, so ist die Fundstelle nicht klar (Da der Parser ja nur auf der Tokenfolge arbeitet). Abhilfe: Der Scanner speichert zu jedem Token den Fundort (Zeile, Spalte)

77 Symboltabellen Während der Syntaxprüfung legt ein Parser eine Symboltabelle an, mit mindestens folgenden Einträgen pro Variable: Name Typ Speicherplatz

78 Symboltabellen Beispiel: float betrag = 10.50; betrag = betrag*(1+zins); Ablauf: Parser findet Deklaration Prüfen, ob Variable bereits vorhanden Eintragen: Name, Typ, neue Adresse Parser findet Anwendung einer Variablen Prüfen, ob Variable bereits vorhanden Benutzen der gespeicherten Adresse für Code

79 Symboltabellen Beispiel:

80 Codeoptimierung Nach der Code-Erzeugung wird noch versucht, das Programm zu optimieren. Dies geschieht meist durch Heuristiken. Beispiele...

81 Codeoptimierung Beispiel: Erkennen identischer Teilausdrücke Original-Code: if (x*x < 255) x = x*x; Ersetzen durch temp = x*x; if (temp < 255) x = temp;

82 Codeoptimierung Beispiel: Propagieren von Konstanten Original-Code: bool debug = true;... if (debug) cout << error << endl; Ersetzen durch cout << error << endl;

83 Codeoptimierung Beispiel: Ersetzen von Berechnungen Original-Code: a = x+x; Ersetzen durch a = x<<1;

84 Codeoptimierung Beispiel: Ausklammern von Konstanten aus Schleifen Original-Code: while (x<100) { sum += y*y+x; x++; } Ersetzen durch temp = y*y; while (x<100) { sum += temp+x; x++; }