5. Bottom up-Parser5. Bottom up-Parser...5. Bottom up-Parser Das Handle Ein Teilstring β einer...

________________________________________________________________________________________________________________________________ H. Kopp, V. Matoušek: Programmiersprachenentwurf / FH Regensburg 5-1

5. Bottom up-Parser

5. Bottom up-Parser 5. Bottom up-Parser

syntaktische Analyse


5. Bottom up-Parser

Beispiel einer Bottom up-Analyse

{ }{ }, , ( , )

=

= + ∗

→ +

= →

→

13

13

13

N

T

P

E,T, F

v,

E T | E T,T F | T * F,F v | (E)

( ) ( ) ( ( )( ) ( ) ( )( ) ( ) ( )

+ + ← + + ← + + ← + +← + + ← + + ← + +← + + ← + + ← +

← + ← ←

v v v F v v T v v) E v vE F v E T v E E vE E F E E T E E

E F E+T E

Vorgegebene Grammatik: Reduktionsfolge:


5. Bottom up-Parser

Das Handle

Ein Teilstring β einer Satzform α β γ heißt Handle, falls

β die rechte Seite einer Produktion β→N ist und

der Reduktionsschritt α β γ α γ← N zu einer linkskanonischen Reduktion fortsetzbar ist.

_____________________________________________________________________________ H. Kopp, V. Matoušek: Programmiersprachenentwurf / FH Regensburg 5-4

5. Bottom up-Parser

Bottom up-Analyse noch einmal:

Schritt: Stackinhalt: Eingaberest: 1. v + ( v + v ) 2. v + ( v + v ) 3. F + ( v + v ) 4. T + ( v + v ) 5. E + ( v + v ) 6. E + ( v + v ) 7. E + ( v + v ) 8. E + ( v + v ) 9. E + ( F + v ) 10. E + ( T + v ) 11. E + ( E + v ) 12. E + ( E + v ) 13. E + ( E + v ) 14. E + ( E + F ) 15. E + ( E + T ) 16. E + ( E ) 17. E + ( E ) 18. E + ( E ) 19. E + F 20. E + T 21. E


5. Bottom up-Parser

LR(k)-Analyseverfahren

Kriterien für den Fortgang der Analyse

Informationen über den gesamten Stackinhalt und die nächsten k Zeichen der Eingabe für ein festes k ≥ 0

Vorteile der LR(k)-Methoden

die Sprachklasse LR(k) ist umfangreicher als die Klasse LL(k) alle üblichen syntaktischen Konstruktionen mit LR(k) anlysierbar tabellengesteuert d.h. effizient implementierbar; k=1 genügt. correct prefix property.


5. Bottom up-Parser

a β τ γ

N τ γ

k

a

LR(k)-Grammatiken

in jeder Satzform ist das Handle β eindeutig bestimmt durch den aktuellen Stackinhalt und die nächsten k Zeichen der Eingabe.


5. Bottom up-Parser

I4

I7

I2

I0

I8

(

∗

T

$

E

LR(k)-Analysator

v ∗ ( v + v ) $

Schaltwerk

Eingabeband

Zustands- Stack

Symbol- Stack


5. Bottom up-Parser

Die Aktionstabelle

Damit entscheidet der Analysator über den nächsten Analyseschritt.

t0 t1 t2 ........... $

I0 ACCEPT

I1 Ik I 2 β→N : :

Mögliche Einträge auf Position ( Ii, tj ) :

Ein Zustand Ik (Aktion = kellern) Eine Produktion β→N (Aktion = reduzieren) ACCEPT (Eingabe als syntaktisch korrekt akzeptieren)


5. Bottom up-Parser

I2

I

I

I

N

N

N

$

N1

Die Goto-Tabelle

Damit bestimmt der Analysator den nächsten Stackzustand bei Reduktionen.

N0 N1 N2 ...........

I0 I1 I2 Ik : :


5. Bottom up-Parser

Die Aktionstabelle von 13Γ

v + * ( ) $

I0 I5 I4 I1 I6 ACCEPT

I2 →E T I7 →E T →E T I3 →T F →T F →T F →T F I4 I5 I4 I5 →F v →F v →F v →F v I6 I5 I4 I7 I5 I4 I8 I6 I11 I9 → +E E T I7 → +E E T → +E E T I10 *→T T F *→T T F *→T T F *→T T F I11 →F (E) →F (E) →F (E) →F (E)


5. Bottom up-Parser

Die Goto-Tabelle von 13Γ

E T F

I0 I1 I2 I3 I1 I2 I3 I4 I8 I2 I3 I5 I6 I9 I3 I7 I10 I8 I9 I10 I11

____________________________________________________________________________________

_____________________________________________________________________________________ H. Kopp, V. Matoušek: Programmiersprachenentwurf / FH Regensburg 5-12

5. Bottom up-Parser

Ablauf einer SLR(1)-Analyse (I)

Schritt Stackinhalt Eingabe Reduktion1. $ v ∗ ( v + v ) + v $

I0

2. $ v ∗ ( v + v ) + v $ ←v F I0 I 5

3. $ F ∗ ( v + v ) + v $ ←F T I0 I 3

4. $ T ∗ ( v + v ) + v $ I0 I 2

5. $ T ∗ ( v + v ) + v $ I0 I 2 I 7

6. $ T ∗ ( v + v ) + v $ I0 I 2 I 7 I 4

7. $ T ∗ ( v + v ) + v $ ←v F I0 I 2 I 7 I 4 I 5

8. $ T ∗ ( F + v ) + v $ ←F T I0 I 2 I 7 I 4 I 3

9. $ T ∗ ( T + v ) + v $ ←T E I0 I 2 I 7 I 4 I 2

10. $ T ∗ ( E + v ) + v $ I0 I 2 I 7 I 4 I 8

11. $ T ∗ ( E + v )+ v $ I 0 I 2 I 7 I 4 I 8 I 6

12. $ T ∗ ( E + v ) + v $ ←v F I 0 I 2 I 7 I 4 I 8 I 6 I 5

13. $ T ∗ ( E + F ) + v $ ←F T I 0 I 2 I 7 I 4 I 8 I 6 I 3

____________________________________________________________________________________

_____________________________________________________________________________________ H. Kopp, V. Matoušek: Programmiersprachenentwurf / FH Regensburg 5-13

5. Bottom up-Parser

Ablauf einer SLR(1)-Analyse (II)

Schritt Stackinhalt Eingabe Reduktion14. $ T ∗ ( E + T ) + v $ + ←E T E

I 0 I 2 I 7 I 4 I 8 I 6 I 9

15. $ T ∗ ( E ) + v $ I 0 I 2 I 7 I 4 I 8

16. $ T ∗ ( E ) + v $ ←(E) F I 0 I 2 I 7 I 4 I 8 I11

17. $ T ∗ F + v $ * ←T F T I 0 I 2 I 7 I 10

18. $ T + v $ ←T E I 0 I 2

19. $ E + v $ I 0 I 1

20. $ E + v $ I 0 I 1 I 6

21. $ E + v $ ←v F I 0 I 1 I 6 I 5

22. $ E + F $ ←F T I 0 I 1 I 6 I 3

23. $ E + T $ + ←E T E I 0 I 1 I 6 I 9

24. $ E $ ACCEPT I 0 I 1


5. Bottom up-Parser

LR(0)-Items N ϕ ψ→

a β γ

ψ ϕ

N

N ϕ ψ→ bedeutet:

Es ist ein Anfang ϕ für das Handle ϕψ gefunden.

Eine Reduktion mit ϕψ ← N ist möglich, wenn noch ψ erreicht werden kann.


5. Bottom up-Parser

LR(0)-Informationen

Eine LR(0)-Information ist eine Menge von LR(0)-Items.

Ziel: LR(0)-Informationensollen alle mögliche Interpretationen der selben Analysesituation darstellen.


5. Bottom up-Parser

Der Operator HUELLE

Er liefert zu einem LR(0)-Item ϕ ψ→N die Menge aller LR(0)-Items, die sich der selben Analysesituation zuordnen lassen wie ϕ ψ→N .

Der Operator wird auf eine LR(0)-Information I angewandt, indem man ihn auf ihre Elemente anwendet.

Verfahren zur Bestimmung der Hülle:

{ nimm I in die Menge HUELLE [ I ] auf } wiederhole für alle LR(0)-Items der Form ϕ ψ→N M in der LR(0)-Information I für alle Produktionen der Form π→M der Grammatik { nimm π→M in die Menge HUELLE [ I ] auf } solange bis HUELLE[ I ] stabil bleibt.


5. Bottom up-Parser

Beispiel zum Operator HUELLE

HUELLE [ → +E E T ] = *

→ + → → → →

E E TT FT T FF vF (E)


5. Bottom up-Parser

Der Operator GOTO

Er beschreibt das Schaltverhalten des Endlichen Automaten, der die Stackzustände ermittelt.

Er liefert zu einer LR(0)-Information I und zu V∈x eine neue LR(0)-Information:

GOTO [ I, x ] = HUELLE [ α β→N x | α β→ ∈ IN x ]

GOTO [ I , ( ] = HUELLE [ ( )→F E ] =

( )

*

→ → → + → →

→ →

F EE TE E TT FT T FF vF (E)

Beispiel:


5. Bottom up-Parser

Die kanonische Kollektion der LR(0)-Informationen (I)

sie stellt die Zustandsmenge des LR(0)-Automaten dar

Verfahren zur Berechnung der kanonschen Kollektion der LR(0)-Informationen

{ nimm die Menge HUELLE [ →X X ] in die Kollektion C auf } wiederhole

für { alle LR(0)-Information I ∈ C und alle Zeichen ∈x V } { nimm GOTO [I, x ] in die Kollektion C auf } solange bis C stabil bleibt.


5. Bottom up-Parser

Die kanonische Kollektion der LR(0)-Informationen (II)

I0 = HUELLE [ →E E ] = *

→

→ → +

→ →

→ →

E EE TE E TT FT T FF vF (E)

→

→ +=

→

→

13P

E EE T |E TT F | T *FF v | (E)

Grammatik:

erste LR(0)-Information:


5. Bottom up-Parser

Die kanonische Kollektion der LR(0)-Informationen (III)

I 1 = GOTO [ I0, E ] = HUELLE →

→ +

E EE E T

= →

→ +

E EE E T

I 2 = GOTO [ I0, T ] = HUELLE *→

→

E TT T F = *

→ →

E TT T F

I 3 = GOTO [ I0, F ] = HUELLE [ ]→T F = [ ]→T F

I 4 = GOTO [ I0, ( ] = HUELLE [ ]( )→F E =

( )

*

→ → → + → →

→ →

F EE TE E TT FT T FF vF (E)


5. Bottom up-Parser

Die kanonische Kollektion der LR(0)-Informationen (IV)

I 5 = GOTO [ I0, v ] = HUELLE [ ]→F v = [ ]→F v

I 6 = GOTO [ I1, + ] = HUELLE [ ]→ +E E T = *

→ + → → → →

E E TT FT T FF vF (E)

I 7 = GOTO [ I2, ∗ ] = HUELLE [ ]*→T T F =

*→ → →

T T FF vF (E)

I 8 = GOTO [ I4, E ] = HUELLE ( )→

→ +

F EE E T =

( )→ → +

F EE E T


5. Bottom up-Parser

Die kanonische Kollektion der LR(0)-Informationen (V)

I 9 = GOTO [ I6, T ] = HUELLE *→ +

→

E E TT T F = *

→ + →

E E TT T F

I 10 = GOTO [ I7, F ] = HUELLE [ ]*→T T F = [ ]*→T T F

I 11 = GOTO [ I8, ) ] = HUELLE [ ]( )→F E = [ ]( )→F E


5. Bottom up-Parser

Der LR(0)-Automat

I4

I3 I2 I1

I0

I9 I8

I7 I6

I5

I11 I10

F

∗

T

F

E

E F

F

)

v

T

v

v v

(

(

∗ (

(

T +

+


5. Bottom up-Parser

Verfahren zur Konstruktion Aktionstabelle

für { alle LR(0)-Informationen Ii ( 0 i n≤ ≤ ) } für { alle Terminalzeichen t ∈ T } falls es ein LR(0)-Item tα β→N in Ii gibt mit GOTO [Ii, t ] = Ij { Trage Ij auf der Position ( Ii, t) in die Aktionstabelle ein. }

für { alle LR(0)-Informationen Ii ( 0 i n≤ ≤ ) } falls es ein LR(0)-Item α→N in Ii gibt

iα→

∈

ITrage N auf allen Positionen ( , t) in die Aktionstabelle ein,

für die t FOLLOW(N) ist

für { alle LR(0)-Informationen Ii ( 0 i n≤ ≤ ) }

falls es ein LR(0)-Item →X X in Ii gibt

{ }IiTrage ACCEPT auf der Position ( , $) in die Aktionstabelle ein


5. Bottom up-Parser

Verfahren zur Konstruktion GOTO-Tabelle

für { alle LR(0)-Informationen Ii ( 0 i n≤ ≤ ) } für { alle N ∈ N } falls GOTO [Ii , N ] = Ij { trage Ij auf der Position ( i, N ) in die GOTO-Tabelle ein }


6. Fehlerbehandlung

6. Die Fehlerbehandlung 6. Die Fehlerbehandlung

Lexikalische Analyse

Code- generierung

Speicher- verwaltung


OptimierungInterpretation

Fehler- Behandlung


6. Fehlerbehandlung

Fehler bei der Software-Entwicklung

Aus der Sicht des Entwicklers unterscheiden wir: Spezifikationsfehler Algorithmische Fehler Codierungsfehler Mißachtung von Sprach- und Compilereigenschaften Compilerfehler


6. Fehlerbehandlung

Fehlerreaktionen des Übersetzers

Mögliche Reaktionen des Compilers im Fehlerfall: keine Reaktion Abbruch der Compilierung Fehlerbehandlung

Angemessene, benutzerfreundliche Fehlerbehandlung:

quellsprachenbezogene Identifikation der Fehlerstelle, aussagekräftige, selbsterklärende Fehlermeldungen, die Vermeidung unnötiger Redundanz


6. Fehlerbehandlung

Klassifikation von Fehlern

Aus der Sicht des Compiler-Entwicklers unterscheiden wir:

Lexikalische Fehler Syntaktische Fehler Semantische Fehler Laufzeitfehler


6. Fehlerbehandlung

Modell der Fehlerbehandlung

Lexikalische Analyse

Code- generierung

Speicher- verwaltung


OptimierungInterpretation

Fehler- Behandlung


6. Fehlerbehandlung

Behandlung lexikalischer Fehler

Typische lexikalische Fehler sind:

Verwendung von Zeichen, die nicht zum Alphabet gehören Zahlbereichsüberschreitung bei Zahlkonstanten Nichteinhalten von Namenskonventionen Falsche Schreibweise von Wortsymbolen


6. Fehlerbehandlung

Beispiel zur Fehlerbehandlung im Scanner:

Fehler in Wortsymbolen

Bei 80% der Fehler in Wortsymbolen sind: ein Zeichen zu viel oder zu wenig vorhanden, ein Zeichen falsch geschrieben, zwei Zeichen vertauscht.

Prüfen, ob das erwartete Wortsymbol falsch geschrieben wurde durch:

Hinzufügen oder Weglassen eines Zeichens, Vertauschen zweier Zeichen, Abändern eines Zeichens.


6. Fehlerbehandlung


Verwechslung von „;“ und „,“ legalisieren Konventionelle Analyse:

if (sym == varSym) { getSym(); varDeclaration(); while (sym == comma) { getSym(); varDeclaration(); } if (sym == semicolon) getSym(); else error(5); }

var ident

, ident

;


6. Fehlerbehandlung


Verwechslung von „;“ und „,“ legalisieren Fehlertolerante Analyse: Was ist der Preis für diese Modifikation ?

if (sym == varSym) { getSym(); do { varDeclaration(ppos); while (sym == comma) { getSym(); varDeclaration(ppos); } if (sym == semicolon) getSym(); else error(5); } while (sym == ident); }

var ident

, ident

;


6. Fehlerbehandlung

S

Z X Y

t


Überlesen von Quelltext

• X muß im Fehlerfall garantieren, daß Y einen brauchbaren Anfang vorfindet.

• Generelle Methode: Überlesen von Quelltext bis zu einem legalen FOLLOW-Zeichen oder einem Stop-Zeichen


6. Fehlerbehandlung

Beispiel zur Fehlerbehandlung im Parser:

Hypothesen über den wahrscheinlichen Fehler Legalisieren von fehlendem then

if (sym == ifSym) { getSym(); condition( STAT_START | IDENT | DO_THEN_OF ); if (sym == thenSym) getSym(); else error(16); statement(followSymSet | UNTIL_ELSE); if (sym == elseSym) { getSym(); statement(followSymSet); } }

then if condition statement


6. Fehlerbehandlung

Weitere Themen der Fehlerbehandlung

Syntaktische Fehler bei der LR- Analyse Fehlersituation: die Aktionstabelle besitzt keinen Eintrag LR-Analysatoren besitzen die correct prefix-Eigenschaft

Semantische Fehler: werden durch kontextfreie Analyse nicht erkannt

fehlende oder falsche Vereinbarungen typfremde Verwendung von Namen


7. Speicherverwaltung

7. Die Speicherverwaltung 7. Die Speicherverwaltung

Speicher- Verwaltung



Begriffe des Speichermanagement

Lebensdauer von Objekten Gültigkeitsbereich von Objekten Statische Speicherverwaltung (COBOL, FORTRAN, PASCAL, C, C++) Dynamische Speicherverwaltung (Pascal, C, C++ ) Programmeinheit Datenraum (DSA = Data Storage Area)



Statische Speicherverwaltung

Merkmale: Inhalt und Größe der Datenräume sind zur Compile-Zeit bekannt der Compiler kann Objekten feste Adressen zuordnen Lebensdauer von Objekten = gesamte Programmlaufzeit

Beispiele statischer Speicherverwaltung:

FORTRAN, COBOL static-Variablen in C-Sprachen globale Variablen in C-Sprachen



Datenraum einer Programmeinheit

void Polar (float x1, float y1, double& radius, double& winkel) { // Umrechnung kartesischer Koordinaten in Polarkoordinaten radius = sqrt ( x1*x1 + y1*y1 ); winkel = atan ( y1 / x1 ); return; }

Wert des Parameter x1 Wert des Parameter y1 Adresse des Parameter radius Adresse des Parameter winkel Länge der Parameterliste

Rückkehradresse Datenraumverkettung Register Save Area

Hilfsvariablen zur Auswertung der Ausdrücke



Datenraum einer Block-Hierarchie (I)

void main() { int x, y; x=1; y=2; cout << "\n\nWerte auf dem Hauptprogramm-Niveau:\n"; cout << "x = " << x << " y = " << y; { int y, z; x=11; y=22; z=33; cout << "\n\nWerte im 1. untergeordneten Block:\n"; cout << "x = " << x << " y = " << y << " z = " << z; } { int a; a = 44; cout << "\n\nWerte im 2. untergeordneten Block:\n"; cout << "x = " << x << " y = " << y << " a = " << a; } getch(); return; }

Run



Datenraum einer Block-Hierarchie (II)

Ablage der Variablen im Arbeitsspeicher für dieses Programm: Objekte des 1. und 2. Unterblocks belegen den selben Platz !

Objekte des 1. Unterblocks: y, z

Objekte des 2. Unterblocks: a

Objekte des Hauptprogramms: x, y



Blockvektoren (I) int main() { int x, y; x=1; y=2; cout << "\n\nWerte auf dem Hauptprogramm-Niveau:\n"; cout << "x = " << x << " y = " << y; { int y, z; x=11; y=22; z=33; cout << "\nWerte im 1. untergeordn. Block:\n"; cout << "x =" << x << " y =" << y << " z =" << z; { int a; a = 44; cout << "\nWerte im 2. untergeordn. Block:\n"; cout << "x =" << x << " y =" << y << " " << "z =" << z << " a =" << a; } } getch(); return 0; } Run



Blockvektoren (II)

Objekte des 2. Unterblocks: a

Objekte des 1. Unterblocks: y, z

Objekte des Hauptprogramms: x, y



Dynamische Speicherverwaltung Jedem Funktionsaufruf wird ein eigener Datenraum bereitgestellt; er enthält:

Eine Datenobjekte Rückkehr-Information Verwaltungsinformation für das Environment

Environment Zum Environment der aktiven Programmeinheit gehören:

ihr eigener Datenraum, die Datenräume der statisch übergeordneten Prozeduren, ist eine Programmeinheit mehrfach gleichzeitig aktiv, so gehört

der Datenraum der jüngsten Aktivierung zum Environment.

____________________________________________________________________________________________ H. Kopp, V. Matoušek: Programmiersprachenentwurf / FH Regensburg 7-10


Datenstack-Verwaltung (I)

// Wahl und Aufruf der naechsten Funktion #define gotoNext .............. // Ausgabe des aktuellen Environment void Environment (char fnct, int e, int f) { .......... } // globale Variablen int a=1, b=2; void A() { int r=random(1000); int s=random(1000); Environment ('A', r, s); gotoNext; Environment ('A', r, s); gotoNext; } void B() { int x=random(1000); int y=random(1000); Environment ('B', x, y); gotoNext; Environment ('B', x, y); gotoNext; } void main() { int p=111, q=222; cout << "Protokoll des akt. Environment:\n\n"; Environment ('M', p, q); A(); Environment ('M', p, q); getch(); return; } Run



Datenstack-Verwaltung (II)

Objekte des Hauptprogramms: p, q

Globale Objekte: a, b

Objekte der Funktion A: r, s



Objekte der Funktion B: x, y




1.

3.

2.

















4.

5.

6.



Datenstack-Verwaltung (IV)

program main var p, q: integer; procedure A; var r, s: integer; begin {A} ......... ......... end; {A} procedure B; var u, v: integer; procedure C; var x, y: integer; begin {C} ......... ......... end; {C} begin {B} ......... ......... end; {B} begin {main} ......... ......... end; {main}

main

A

B

C

Objekte von C: x, y

Objekte von C: x, y

Objekte von B: u, v

Objekte von A: r, s

Objekte von main: p, q Aufrufreihenfolge: main → A → B → C → C

_______________________________________________________________________________________________________________________________ H. Kopp, V. Matoušek: Programmiersprachenentwurf / FH Regensburg 7-13


Rückkehrverwaltung mit Dynamic Links




Objekte von main: p, q

Globale Objekte: a, b Aufrufreihenfolge: main → A → B → C



Environment-Verwaltung mit Static Links

Merkmale: Static Link-Zeiger verketten alle Datenräume, die zum Environment

einer Programmeinheit gehören

Objekte werden adressiert über:

die Niveau-Differenz zwischen dem Niveau ihrer Verwendung und dem Niveau ihrer Vereinbarung und

ihre Distanz zur Basis des Datenraums, dem sie angehören.



Beispiel 1 zu Static Links

(Bezug: C-Programm aus Beispiel 7.4)






A

B

main

globals



Beispiel 2 zu Static Links

(Bezug: Pascal-Programm aus Beispiel 7.5)

Objekte von C: x, y

Objekte von C: x, y

Objekte von B: u, v

Objekte von A: r, s


A

B

C

main



Initialisierung der Static Links

Gehe vom Datenraum der aufrufenden Prozedur in der Static Link-Kette um (n-m+1) Schritte zurück. Dabei gilt:

n = Deklarationsniveau der aufrufenden Funktion m = Deklarationsniveau der gerufenen Funktion

Setze den Static Link-Zeiger der neu aktivierten Prozedur auf den so erreichten Datenraum.



Beispiele zur Initialisierung der zu Static Links

Aufruf erfolgt im Aufgerufene

Funktion Dekl.-Level

des Aufrufs (n)

Dekl.-Level d. gerufenen Funktion (m)

(n-m+1) Schritte zurück

Ziel des Link

Rumpf von main A 1 2 0 main Rumpf von A B 2 2 1 main Rumpf von B A 2 2 1 main

Rumpf von B C 2 3 0 B Rumpf von C A 3 2 2 main Rumpf von C B 3 2 2 main

(Bezug: Pascal-Programm aus Beispiel 7.5)

A

B

C

main



Environment-Verwaltung mit Displays

Objekte werden adressiert über:

das statische Niveau ihrer Deklaration die Distanz zur Basis des

Datenraumes, dem sie angehören

Objekte von C: x, y

Objekte von C: x, y

Objekte von B: u, v

Objekte von A: r, s




Initialisierung der Display-Vektoren

Der Display-Vektor wird beim Anlegen eines Datenraumes initialisiert: (m = Niveau des Aufrufs, n = Niveau der gerufenen Funktion):

Übernimm den Display-Vektor aus dem Datenraum der rufenden Prozedur für die Indexpositionen 0, 1, ... , m-1.

Trage auf der Position m die Adresse des neu angelegten Datenraumes ein.



Felder mit dynamischen Grenzen

In Pascal: arrayA: array[u..n, v..m] of ... ;

In C++: int i, n; long *arrayA; cin >> n; arrayA = new long [n]; for (i=0; i<n; i++) { cout << "arrayA[" << i << "] = "; cin >> arrayA[i]; }



Deskriptoren für Felder mit dynamischen Grenzen

DSA -Top pointer

Deskriptor von arrayA

Daten von arrayA

DSA -Top pointer

Deskriptor von arrayA



Allgemeiner Aufbau von Feld-Deskriptoren

FeldA : array [u1..o1, u2..o2 , ... , un..on] of …

u1 o1 s1 u2 o2 s2 . . . . . . . . . un on sn

α0



Beispiel: Feld-Deskriptor und Anordnung der Feld-Daten

A : array [1..4, 2..3] of integer;

u1 = 1 o1 = 4 s1 = 8 u2 = 2 o2 = 3 s2 = 4 α0 = ......

Deskriptor

logische Anordnung

physikalische Anordnung:

A[1,2] A[1,3] A[2,2] A[2,3] A[3,2] A[3,3] A[4,2] A[4,3]

A[1,2] A[1,3] A[2,2] A[2,3] A[3,2] A[3,3] A[4,2] A[4,3]



Beispiel zur Adreßrechnung A : array [1..4, 2..3] of integer;

( )( [ , ] ) 1 *

( 2) *

A i j i

j

α= + − +

+ −

Adresse Länge einer Zeile

Länge einer Komponente

0

( [ , ] ) ( 1)*8 ( 2)*4(1*8 2*4) ( *8 *4)( *8 *4)

A i j i ji j

i j

ααα

= − − + −= − + + += + +

Adresse

0 (1*8 2*4)α α= − +



Allgemeine Adreßrechnung

( )( )

( )

1

0 1 1 2 2

1 0 1 1 2 2

1 * , 1, ..... , 2

* * ..... *

( [ ,..., ] ) * * ..... *

n

k k k k

n n

n n n

s

s o u s n n

u s u s u s

A i i i s i s i s

α α

α

−

=

= − + −

= − + + +

= + + + +

Länge einer Feldkomponente

für

Adresse

_______________________________________________________________________________________________________________________________ H.Kopp, V. Matoušek: Programmiersprachenentwurf / FH Regensburg 8-1

8. Syntaxorientierte Übersetzung

8. Syntaxorientierte Übersetzung 8. Syntaxorientierte Übersetzung

Code- generierung

Inter- pretation



Zwischensprachen (I): Quadrupelsprachen Zwischensprachen (I): Quadrupelsprachen

die Anweisungen sind Dreiadreßbefehle

Operator 1. Operand 2. Operand 3. Operand

Quadrupelcode für die Zuweisung Z = A ∗ B + C ∗ D;

1: MPY A B $HV1 2: MPY C D $HV2 3: ADD $HV1 $HV2 $HV3 4: STORE $HV3 Z



Zwischensprachen (II): Tripelsprachen

die Anweisungen sind Zweiadreßbefehle

Operator 1. Operand 2. Operand

Tripelcode für die Zuweisung Z = A ∗ B + C ∗ D;

1: MPY A B 2: MPY C D 3: ADD (1) (2) 4: STORE (3) Z



Zwischensprachen (III): Postfixsprachen

die Anweisungen besitzen einen oder gar keinen expliziten Operanden weitere implizite Operanden liegen im Stack Jede Operation hat eine eindeutige Zahl von Operanden

Postfixcode für die Zuweisung Z = A ∗ B + C ∗ D ;

1: LOAD A 2: LOAD B 3: MPY 4: LOAD C 5: LOAD D 6: MPY 7: ADD 8: STORE Z



Übersetzung von Ausdrücken in Quadrupelcode (I)

Ziel: Generierung von Zwischencode bei der syntaktischen Analyse

Methode: Der Analysestack wird so erweitert, daß während der Analyse semantische Informationen mitgeführt werden können.

Beispiel:

{ }{ }, , ( , )

=

= + ∗

→ +

= →

→

13

13

13

N

T

P

E , T

v ,

E T | E TT F | T *FF v | (E)



Übersetzung von Ausdrücken in Quadrupelcode (II)

Semantische Informationen und Aktionen

Als semantische Information merken wir uns Variablen und Hilfsvariablen in einem Array HV . HV[i] bezeichnet sein i-tes Element.

Wenn der Parser eine syntaktische Struktur erkennt erzeugt er mit einer Funktion

generate (...) eine Zwischencode-Anweisung im Quadrupel-Format.

Notation: sem(sym) verweist auf die semantische Information zum Token sym .



Übersetzung von Ausdrücken in Quadrupelcode (III)

Die semantischen Aktionen zu den Produktionen von 13Γ sind:

→E T sem(E) := sem(T)

→ +1 2E E T i ++ sem(E1) := hv[i] generate (ADD, sem(E2), sem(T), hv[i])

→T F sem(T) := sem(F)

→ ∗1 2T T F i ++ sem(T1) := hv[i] generate (MPY, sem(T2), sem(F), hv[i] )

→F v sem(F) := sem(v)

→F (E) sem(F) := sem(E)

____________________________________________________________________________________ H.Kopp, V. Matoušek: Programmiersprachenentwurf / FH Regensburg 8-8


Ablauf der Übersetzung von (A+B)∗C Schritt Stackinhalt Eingabe ZwischenCode

1. ( A + B ) ∗ C

2. ( A + B ) ∗ C

3. ( v + B ) ∗ C A

4. ( F + B ) ∗ C A

5. ( T + B ) ∗ C A

6. ( E + B ) ∗ C A

7. ( E + B ) ∗ C A

8. ( E + v ) ∗ C A B

9. ( E + F ) ∗ C A B

10. ( E + T ) ∗ C A B

Übersetzung von Ausdrücken in Quadrupelcode (IV)

____________________________________________________________________________________ H.Kopp, V. Matoušek: Programmiersprachenentwurf / FH Regensburg 8-9


Ablauf der Übersetzung von (A+B)∗C

11. ( E ) ∗ C ADD A B hv[1] hv[1]

12. ( E ) ∗ C hv[1]

13. F ∗ C hv[1]

14. T ∗ C hv[1]

15. T ∗ C hv[1]

16. T ∗ v hv[1] C

17. T ∗ F hv[1] C

18. T MPY hv[1] C hv[2] hv[2]

19. E hv[2]

Übersetzung von Ausdrücken in Quadrupelcode (IV)



Übersetzung von Ausdrücken in Postfixcode (I)

Beispiel-Grammatik 11Γ

{ }{ }

{ }{ }

, , , , / , ( , )

[ | ]

| | ( )

, ,

,

=

= + − ∗

→ + − + −

= → ∗

→

11

11

11

N

T

P

expr term fact

ident number

expr term term | term

term fact fact | / fact

fact ident number expr



Übersetzung von Ausdrücken in Postfixcode (II) Die Architektur der Zielmaschine

LOAD v bringt den Wert der Variablen v in den Stack

LIT c bringt den Wert der Konstanten c in den Stack

NEG negiert den obersten Stackeintrag

ADD addiert die obersten beiden Stackelemente und legt das Resultat wieder in den Stack

SUB subtrahiert die obersten beiden Stackelemente und legt das Resultat wieder in den Stack

MPY multipliziert die obersten beiden Stackelemente und legt das Resultat wieder in den Stack

DIV dividiert die obersten beiden Stackelemente und legt das Resultat wieder in den Stack



Übersetzung von Ausdrücken in Postfixcode (III)

Die semantischen Aktionen zu 11Γ :

Semantik von: | | ( )→fact ident number expr

für die Struktur ident: erzeuge LOAD v für die Struktur number: erzeuge LIT c für die Struktur ( expr ): keine semantische Aktion erforderlich !



Übersetzung von Ausdrücken in Postfixcode (IV)

Die semantischen Aktionen zu 11Γ :

Semantik von { }[ | ]→ + − + −expr term term | term

für das Vorzeichen − wird eine NEG-Anweisung generiert, sobald der Operand verarbeitet ist.

Für die Teilstrukturen + term und - term , wird zuerst der Operand verarbeitet und dann die Operation generiert

Semantik von { }→ ∗term fact fact | / fact

Für die Teilstrukturen ∗ term und / term , wird zuerst der Operand verarbeitet und dann die Operation generiert

___________________________________________________________________________________ H.Kopp, V. Matoušek: Programmiersprachenentwurf / FH Regensburg 8-13


Übersetzung von Ausdrücken in Postfixcode (V)

Codegenerierung mit einem Recursive Descent-Übersetzer für Ausdrücke (A):

void exprParser::expression (void) { char plusMinus[6]; if ((sym==plus) || (sym == minus)) { if (sym==minus) strcpy (plusMinus, "NEG\n"); else strcpy (plusMinus, "" ); getSym(); term(); if (strlen(plusMinus)>0) cout << plusMinus ; } else { term(); } while((sym==plus) || (sym == minus)) { if (sym==plus) strcpy (plusMinus, "ADD\n"); else strcpy (plusMinus, "SUB\n"); getSym(); term(); cout << plusMinus ; } } void exprParser::term(void) { char timesSlash[6]; factor(); while ((sym==times) || (sym == slash)) { if (sym==times) strcpy (timesSlash, "MPY\n"); else strcpy (timesSlash, "DIV\n"); getSym(); factor(); cout << timesSlash ; } }

___________________________________________________________________________________ H.Kopp, V. Matoušek: Programmiersprachenentwurf / FH Regensburg 8-14


Übersetzung von Ausdrücken in Postfixcode (VI)

Codegenerierung mit einem Recursive Descent-Übersetzer für Ausdrücke (B):

void exprParser::factor(void) { switch (sym) { case ident: getSym(); cout << "LOAD " << id << endl; break; case number: getSym(); cout << "LIT " << num << endl; break; case lparen: getSym(); expression(); if (sym == rparen) getSym(); else cout << "Symbol can't follow an expression !\n; break; default: cout << "factor expected !" << endl; break; } } Übersetzung einer Beispieldatei

Run

alpha + beta/12; pi*2/(radius1-radius2);(x17 - x18) / 15; a*b+c.



Übersetzung bedingter Anweisungen (I)

Struktur des zu erzeugenden Code:

Code zur Auswertung der condition

jump on false L1

Code zur Auswertung des statement

nachfolgender Code

then if condition statement

L1:



Übersetzung bedingter Anweisungen (II)

case ifSym: getSym(); condition( STAT_START | IDENT | DO_THEN_OF, lev ); if (sym==thenSym) getSym(); else error(16); fixup1 = cx; // Adresse des jpc-Befehls merken generate (jpc, 0, 0); // then-Zweig bedingt umgehen statement(followSymSet | UNTIL_ELSE, lev); code[fixup1].a = cx; // Adresse des jpc-Befehls setzen break;



Der PL/0-Übersetzer

Die Struktur der Symboltabelle (I)

int tx; // symbol table index struct // symbol table: { objType kind; // object type of this entry char name[CMAX+1]; // object identifier union { int val; // numerical value for constants struct { int level; // address information int addr int size; }; }; } symTable[TXMAX];




Die Struktur der Symboltabelle (II)

Einträge für Konstanten:

Konstanten-Name constObj Konstanten-Wert

Einträge für Variablen:

Variablen-Name varObj DeklarationsLevel Relativadr. in der DSA

Einträge für Prozeduren:

Prozedur-Name procObj DeklarationsLevel Adr. der 1. Anweisung DSA-Größe




Die Datenraum-Struktur

Static Link Dynamic Link Rückkehradresse lokale Variablen lokale Hilfsvariablen



Der PL/0-Übersetzer Zwischencode-Anweisungen (I)

Transportoperationen:

LIT n bringe einen Literalwert n in den Hilfsvariablenstack

LOD l , a bringe Variable mit der Relativdistanz a und der Niveaudifferenz l in den Stack

STO l , a bringe das Stacktop-Element in Variable mit der Relativdistanz a und der Niveaudifferenz l

INC n Reserviere n Plätze im Laufzeit-Stack für den nächsten Datenraum

Sprungbefehle:

JPU a springe zur Anweisung mit der Adresse a

JPC a Jump on false zur Code-Adresse a

CAL a Aufruf der Prozedur mit der Codeadresse a. (DSA anlegen, initialisieren, springen)

RET Rückkehr aus einer Prozedur



Der PL/0-Übersetzer Zwischencode-Anweisungen (II)

Arithmetische Operationen

ADD addiere zwei Summanden. SUB subtrahiere das oberste Stackelement vom darunter stehenden MPY multipliziere zwei Faktoren. DIV Dividiere das vorletzte Stackelement durch das oberste. NEG negiere das oberste Stackelement.

Logische Operationen

OD Ist der (einzige) Operand ungerade ?

EQ Sind beide Operanden gleich ?

NE Sind beide Operanden ungleich ?

LE Ist der erste Operand kleiner oder gleich dem zweiten ?

GE Ist der erste Operand größer oder gleich dem zweiten ?

LS Ist der erste Operand kleiner als der zweite ?

GT ist der erste Operand größer als der zweite ?



Der PL/0-Übersetzer Zwischencode-Generator

void pl0Parser::generate(opCode opc, int lv, int ad) { if (cx > CODEMAX) error(31); // too many code entries else { code[cx].o = opc; // generate operation code[cx].l = lv; // generate level difference code[cx].a = ad; // generate address cx++; // point to next free entry } }

5. Bottom up-Parser5. Bottom up-Parser...5. Bottom up-Parser Das Handle Ein Teilstring β einer...

Documents

Transcript of 5. Bottom up-Parser5. Bottom up-Parser...5. Bottom up-Parser Das Handle Ein Teilstring β einer...