Theorie der Programmiersprachen

Präsentation zum Thema: "Theorie der Programmiersprachen"—  Präsentation transkript:

1 Theorie der Programmiersprachen
© Günter Riedewald Die Folien sind eine Ergänzung der Vorlesung und nur für den internen Gebrauch konzipiert.

2 Motivation Eines der fundamentalen Probleme der Informatik ist die Beziehung Syntax-Semantik In der Vorlesung wird dieses Problem für Programmiersprachen behandelt, da - Programmiersprachen mit am besten erforscht sind - und eine wichtige praktische Bedeutung als Werkzeug der Softwareentwicklung haben

3 Beziehung Syntax-Semantik Beispiele
Nachricht Interpretation Information Zeichenkette ohne Bedeutung a + z Addition zweier Operanden vom gleichen Typ Nachricht an Objekt a mit Methode + und Parameter z

4 ADT zur Beschreibung von Datenstrukturen:
Signatur beschreibt Struktur (über Terme) Termgleichungen beschreiben Eigenschaften der Operationen; Termersetzungsregeln beschreiben Ausführung der Operationen Verifikation: Verallgemeinerte Formel {Q} p {R} Q, R Formeln; p Programmstück Bedeutung (durch Interpretation): Wenn Q gilt und p terminiert, dann gilt auch R. (Partielle Korrektheit)

5 TGI: regulärer Ausdruck  reguläre Sprache
Beispiel: a.b Verkettung der regulären Ausdrücke a und b  L(a.b) = L(a).L(b) zu a.b zugeordnete Sprache

6 Programmiersprachen als Werkzeug der Softwareentwicklung
Programmiersprachen sind für unterschiedliche Einsatzgebiete unterschiedlich gut geeignet  Weiterentwicklung der Softwaretechnik erfordert neue Programmiersprachen  ständig neuer Bedarf an Compilern/ Interpretern  Notwendigkeit der schnellen und effizienten Entwicklung von Compilern/ Interpretern (Automatisierung!)

7 Möglichkeiten der Beschreibung von Programmiersprachen
In natürlicher Sprache: + (scheinbare) schnelle Verständlichkeit - Missverständnisse wegen Mehrdeutigkeit der natürlichen Sprachen  Compiler realisieren unterschiedliche Sprachvarianten - Keine Möglichkeit der Verifikation von Compilern und Programmen

8 Formalisierte Beschreibung:
- Anspruchsvolles Kenntnisniveau der Anwender bzgl. Theorie + Nachteile der Beschreibung in natürlicher Sprache verschwinden + Möglichkeit der automatisierten Erstellung von Compilern (Basis: Grammatiken, Automaten) Pragmatisches Vorgehen: Gegeben: universelle Programmiersprache P mit Compiler Zu definieren: Spezialsprache S mit Compiler

9 Voraussetzung: P und S seien verwandt a) S als Untersprache von P (unter Nutzung von Typkonzept, Prozedurkonzept, Operatorkonzept,...)  kein neuer Compiler b) S als Erweiterung von P: - Makroerweiterung: neue Konstrukte von S werden durch Makros in P beschrieben  Makrogenerator und Compiler von P - Präcompilerkonzept: neue Konstrukte von S werden als Kombinationen von Konstrukten aus P definiert  Präcompiler und Compiler von P

10 Programm in S Präcompiler Programm in P Compiler für P Programm in Zielcode

11 Literatur R. Cezzar: A Guide to Programming Languages Overview and Comparison, ARTECH HOUSE,Inc.,1995 E. Fehr: Semantik von Programmiersprachen, Studienreihe Informatik, Springer-Verlag, 1989 R. A. Finkel: Advanced Programming Language Design, Addison-Wesley, 1996

12 M.J.C. Gordon: The Denotational Description of Programming Languages - An Introduction, Springer-Verlag, 1979 C.A. Gunter: Semantics of Programming Languages Structures and Techniques, The MIT Press, 1993 B. Kirkerud: Programming Language Semantics Imperative and Object Oriented Languages, International Thomson Computer Press, 1997 K.C. Louden: Programmiersprachen Grundlagen, Konzepte, Entwurf International Thompson Publ., 1994

13 M.E. Majster: A Unified View of Semantics Technical Report TR , Dept. of Comp. Sc., Cornell University M. Marcotty, H.F. Ledgard, G.V. Bochmann: A Sampler of Formal Definitions, ACM Computing Surveys 8,2(1976), P.D. Mosses: Action Semantics Cambridge University Press, 1992 H.R. Nielson, F. Nielson: Semantics with Applications A Formal Introduction, John Wiley & Sons, 1992

14 F.G. Pagan: Formal Specification of Programming Languages: A Panoramic Primer Prentice-Hall, 1981 G. Riedewald, J. Maluszynski, P. Dembinski: Formale Beschreibung von Programmiersprachen Eine Einführung in die Semantik, Akademie-Verlag Berlin, Oldenbourg Verlag München, 1983 R.W. Sebesta: Concepts of Programming Languages Addison-Wesley, 5. Auflage, 2002

15 K. Slonneger, B.L. Kurtz: Formal Syntax and Semantics of Programming Languages A Laboratory Based Approach Addison-Wesley Publ. Company, 1995 G. Winskel: The Formal Semantics of Programming Languages An Introduction The MIT Press, 1993

16 Theorie der Programmiersprachen 1 Einleitung
Komponenten einer Programmiersprache: Syntax: Beschreibung von Struktur und Aussehen der Sprachkonstrukte (Syntaxbaum und Programmrepräsentation) Semantik: Beschreibung der Bedeutungen der Sprachkonstrukte bzgl. eines bestimmten Bedeutungsraums Bauer/Goos: Bedeutung eines Programms als Funktion seines Syntaxbaums

17 F. L. Bauer, G. Goos in Informatik, II. Teil, Springer, 1971:
Ein Wort aus dem Sprachschatz einer formalen Sprache trägt verschlüsselt in sich den zugehörigen Strukturbaum, den die syntaktische Analyse freilegt. Was durch das Wort an Bedeutung übermittelt wird, muss eine Funktion des Strukturbaums sein. Damit ergibt sich die Forderung, dass die Syntax einer bedeutungstragenden Sprache bedeutungstreu sein muss: sie muss es erlauben, an das Skelett der syntaktischen Struktur unter allen Umständen das Fleisch der Semantik hängen zu können.

18 Fragen: - Welche Bedeutungsräume kommen in Frage?
- Wie ist diese Funktion zu definieren? Pragmatik: gibt die Beziehungen der Sprache zur Umwelt (Nutzer, Rechner, Betriebssystem,...) an  erscheint nicht explizit in der Sprachdefinition („nicht weiter definiert“) Frage: Wozu gehören Kontextbedingungen einer Programmiersprache?  statische Semantik

19 Pragmatik in einer Prolog III-Definition: The boolean and arithmetical operations have their usual mathematical meaning. Rational numbers are represented in the machine in perfect precision, i.e., with as many digits as is required to express them exactly. Of course this is subject to the condition that this must not exceed your computer´s memory capacity.

20 Beschreibungsmittel für Sprachkomponenten:
Syntax: kontextfreie Grammatiken in verschiedenen Ausprägungen (Syntaxdiagramme, BNF, EBNF, van Wijngaarden-Notation,...)  Existenz von nichtdeterministischen Kellerautomaten zur Spracherkennung (syntaktische Analyse in Compilern) Semantik: - verbal - halbformal durch Aktionen eines hypothetischen Rechners

21 - indirekt durch Compiler/Interpreter – Translationssemantik
- mathematische Beschreibungsmittel (streng formal) - Selbstdefinition: Semantik der Sprache wird in der Sprache selbst beschrieben

22 Ergänzung zu Syntaxbäumen Beispiel: kontextfreie Grammatik
2 Konkrete und abstrakte Syntax 2.1 Ergänzungen zu kontextfreien Sprachen Ergänzung zu Syntaxbäumen Beispiel: kontextfreie Grammatik prog: <Programm> ::= begin <Vereinbarungen>;<Anweisungen> end verein1: <Vereinbarungen> ::= <Vereinbarung> verein2: <Vereinbarungen> ::= <Vereinbarung>;<Vereinbarungen> ver: <Vereinbarung> ::= <Typ> <Identifikator> typi: <Typ> ::= int

23 typb: <Typ> ::= bool
idx: <Identifikator> ::= x idy: <Identifikator> ::= y anweis1: <Anweisungen> ::= <Anweisung> anweis2: <Anweisungen> ::= <Anweisung>;<Anweisungen> anweis: <Anweisung> ::= A Syntaxbäume von begin int x; A end in linearer Darstellung: Programm(begin Vereinbarungen(Vereinbarung(Typ(int) Identifikator(x))) ; Anweisungen(Anweisung(A)) end)

24 Kantorovič-Schreibweise:
prog(verein1(ver(typi, idx)), anweis1(anw)) oder als Kantorovič-Baum prog verein1 anweis1 ver anw typi idx

25 Gewöhnliche grafische Darstellung:
Programm begin end Vereinbarungen ; Anweisungen Vereinbarung Anweisung Typ Identifikator A int x

26 Gewöhnliche grafische Darstellung mit Regelbezeichnungen:
Programm begin prog end Vereinbarungen ; Anweisungen verein anweis1 Vereinbarung Anweisung ver anw Typ Identifikator A typi idx int x

27 Kontextfreie Grammatik Algebraische Betrachtung
Vorgehensweise: Nichtterminale werden als Sorten verwendet Syntaxregeln werden als syntaktische Operationen aufgefasst, die Sprachkonstrukte zu komplexeren Konstrukten zusammensetzen  Verwendung von Regelbezeichnungen als Operationssymbole

28 Beispiel: Signatur der obigen Grammatik
Programm prog Vereinbarungen Anweisungen verein verein2 anweis anweis2 Vereinbarung Anweisung ver Typ Identifikator anw typi typb idx idy

29 Bemerkungen: Durch die algebraische Betrachtungsweise wird von der konkreten Programmrepräsentation abstrahiert. Ableitbare Terme sind Syntaxbäume in Kantorovič-Schreibweise. Um Programmeigenschaften festzulegen müssen zusätzlich Termgleichungen definiert werden. Über Algebren können z.B. konkrete Programmrepräsentationen oder konkrete Syntaxbäume definiert werden.

30 a) - Zuordnung einer Trägermenge MX = {w|X + w, w  T*}
Beispiel: a) - Zuordnung einer Trägermenge MX = {w|X + w, w  T*} zu einem Nichtterminal X Z.B.: <Programm>  {w|<Programm> + w, w  T*} - Zuordnung einer typisierten Verkettungsoperation oa : MX1x...xMXn  MX zum Operationssymbol o: X1x...xXn  X Z.B. prog: Vereinbarungen x Anweisungen  Programm  proga: Mvereinbarungen x MAnweisungen  MProgramm

31 Dabei gilt: proga(x, y) = begin x; y end , x  Mvereinbarungen, y  Manweisungen b) - Zuordnung der Menge aller Syntaxbäume mit der Wurzel X zum Nichtterminal X - Zuordnung von typisierten Verkettungen von Syntaxbäumen als Operationen zu den entsprechenden Operationssymbolen

32 Substitution kontextfreier Sprachen
Beispiel: Beschreibung der Grobstruktur von Zahlen: L = {s dn k dm|n > 0, m  0}, s Vorzeichen, k Trennzeichen, d Ziffer, T = {s, d, k} Alphabet Verfeinerung zu Dezimalzahlen mit Vorzeichen: Ls = {+,-} Ld = {0, 1,..., 9} Lk = {,} werden in L „eingesetzt“  L´ Menge aller Dezimalzahlen

33 Verfeinerung zu Binärzahlen mit Vorzeichen:
Ls = {+,-} Ld = {0, 1} Lk = {.}  L´ Menge aller Binärzahlen Substitution kontextfreier Sprachen: Gegeben: Kontextfreie Sprache L (zu verfeinernde Sprache) über einem Alphabet T {Lt}tT Familie kontextfreier Sprachen Lt über einem Alphabet T´ (Verfeinerung) Substitutionssprache L´ (verfeinerte Sprache): x1...xn  L´  t1...tn  L, ti  T, xi  Lti

34 2.2 Beschreibungsmittel kontextfreier Sprachen
Backus-Naur-Form (BNF) Syntaxbeschreibung durch endliche Menge von Metaregeln: Metavariable: in spitze Klammern eingeschlossene Folge von Schriftzeichen Metakonstante: spezielle Schriftzeichenfolge Metaregel: Metavariable gefolgt von ::= mit anschließender Folge aus Metavariablen oder Metakonstanten

35 Zusammenfassung von Metaregeln mit gleicher linker Seite:
<V> ::= 1 , ... , <V> ::= n  <V> ::= 1|...| n (*) Interpretation einer Menge von Metaregeln (*): Metavariable: Unbekannte in einem Mengengleichungssystem; gesuchter Wert ist eine Sprache Metakonstante: Bestandteil von Worten Metaregel: Mengengleichung, wobei (*) bedeutet Die V zugehörige Sprache ist eine Vereinigung der den i zugehörigen Sprachen

36 Beispiel: BNF-Regeln:
<Identifikator> ::= <Buchstabe>| <Identifikator><Buchstabe>|<Identifikator><Ziffer> <Buchstabe> ::= A|...|Z <Ziffer> ::= 0|1|...|9 Mengengleichungssystem: I = B  I.B  I.Z B = {A,..., Z}, Z ={0, 1,...,9} Gesucht: L(<Identifikator>) = I

37 Fragen: Wann hat das System eine Lösung? Wie viel Lösungen existieren? Welche Lösungsalgorithmen gibt es? Algorithmus: Beginnend mit einem Startwert berechne eine Folge von Näherungen bis zur „Konvergenz“.

38 Hier: Startwert: I0 =  n-te Näherung: In ist die Menge aller Zeichenfolgen beginnend mit Buchstaben und mit nachfolgend maximal (n-1) Buchstaben oder Ziffern Lösung: I = B.(B  Z)* Bemerkung: Die Lösungssprachen eines durch eine BNF definierten Gleichungssystems sind kontextfreie Sprachen.

39  Metaregeln entsprechen kontextfreien Syntaxregeln:
Metavariablen entsprechen Nichtterminalen Metakonstante sind mit Terminalen gleichzusetzen.  Eine BNF kann einer kontextfreien Grammatik gleichgesetzt werden.

40 Kontextfreie Grammatik der Beispielprogrammiersprache BPS
Grundversion 1 <Programm> ::= begin <Vereinbarungen> ; <Anweisungen> end 2 <Vereinbarungen> ::= <Vereinbarung>| <Vereinbarung> ; <Vereinbarungen> 3 <Vereinbarung> ::= <Typ> <Identifikator> 4 <Typ> ::= int|bool 5 <Anweisungen> ::= <Anweisung>| <Anweisung> ; <Anweisungen>

41 6 <Anweisung> ::= skip| <Variable> := <Ausdruck>| if <Ausdruck> then <Anweisungen> else <Anweisungen> fi| while <Ausdruck> do <Anweisungen> od| read <Variable>| write <Ausdruck> 7 <Ausdruck> ::= <Konstante>| <Variable>| (<op1> <Ausdruck>)| (<Ausdruck> <op2> <Ausdruck>) 8 <Variable> ::= <Identifikator>

42 9 <Konstante> ::= <log. Konstante>| <arith
9 <Konstante> ::= <log. Konstante>| <arith. Konstante> 10 <log. Konstante> ::= true|false 11 <arith. Konstante> ::= + <Zahl>|- <Zahl>|<Zahl> 12 <Zahl> ::= <Ziffer>|<Zahl><Ziffer> 13 <Ziffer> ::= 0|1|...|9 14 <op1> ::= +|-|not 15 <op2> ::= +|-|/|*|=|||||||and|or 16 <Identifikator> ::= <Buchstabe>| <Identifikator><Buchstabe>|<Identifikator><Ziffer> 17 <Buchstabe> ::= a|b|...|z

43 Jede Variable darf höchstens einmal vereinbart sein.
Ausgewählte Kontextbedingungen Jede in einem Ausdruck oder einer Anweisung auftretende Variable muss im gleichen Programm vereinbart sein. Jede Variable darf höchstens einmal vereinbart sein. In einer Wertzuweisung müssen die Typen der Variablen auf der linken Seite und des Ausdrucks auf der rechten Seite übereinstimmen. Die Typen der Operanden eines dyadischen (zweistelligen) Ausdrucks müssen übereinstimmen. ...

44 Spracherweiterungen 18 <Anweisung> ::= <Block> 19 <Block> ::= begin <Vereinbarungen> ; <Anweisungen> end 20 <Vereinbarung> ::= array [<arith. Konstante>] <Typ> <Identifikator> 21 <Variable> ::= <Identifikator>[<Ausdruck>]

45 Vorteile und Schranken der Verwendung kontextfreier Grammatiken
Entscheidbarkeit kontextfreier Sprachen ( nichtdeterministischer Kellerautomat  Syntaxanalysator in Compilern) Syntaxbäume als Mittel der Strukturbeschreibung und als Voraussetzung für Semantikdefinition (in Compilern Codedefinition) Substitution als Voraussetzung für modulare Sprachdefinition (schrittweise Verfeinerung)

46 Nachteil: Kontextbedingungen sind nicht durch kontextfreie Grammatiken definierbar (Beweis über Pumping Lemma für kontextfreie Sprachen). Ist G = (N, T, P, S) die kontextfreie Grammatik, die die Syntax einer Programmiersprache beschreibt, und ist P die entsprechende Sprache, die die Kontextbedingungen erfüllt, dann gilt: P  L(G)  T*

47 2.3 Abstrakte Syntax und ihre Beschreibungsmittel
Abstrahiert von der konkreten Repräsentation einer Sprache Enthält nur die Strukturelemente, die für die Semantikdefinition wichtig sind Beispiel: konkreter und abstrakter Syntaxbaum von x := (x1 * 3)

48 Anweisung Konkreter Syntaxbaum Variable := Ausdruck Identifikator ( op2 ) Buchstabe Ausdruck * Ausdruck x Variable Konstante Identifikator arith. Konstante Identifikator Ziffer Zahl Buchstabe 1 Ziffer x 3

49 := Abstrakte Syntaxbäume x * x1 3 Anweisung x Ausdruck * x1 3

50 Formen abstrakter Syntax Beispiel BPS
1.Variante Syntaktische Kategorien: Programm, Anweisung, Ausdruck, Deklaration, Operationssymbol1, Operationssymbol2, Identifikator, Arithmetische Konstante, Logische Konstante, Typ Regeln: Programm ::= Deklaration* Anweisung+ Deklaration ::= Identifikator Typ Anweisung ::= Ausdruck Anweisung+ Anweisung+ Anweisung ::= Identifikator Ausdruck

51 Anweisung ::= Ausdruck Anweisung+ Anweisung ::= Identifikator Anweisung ::= Ausdruck Ausdruck ::= Konstante| Identifikator| Arith_Konstante| Log_Konstante| Operationssymbol1 Ausdruck| Operationssymbol2 Ausdruck Ausdruck Variation durch Metavariablen: An  Anweisung, I  Identifikator, Au  Ausdruck An ::= I Au| Au An1+ An2+|

52 2. Variante Programm ::= prog(Deklaration
2. Variante Programm ::= prog(Deklaration*, Anweisung+) Deklaration ::= dekl(Identifikator, Typ) Anweisung ::= if(Ausdruck, Anweisung+, Anweisung+) Anweisung ::= assign(Identifikator, Ausdruck) Anweisung ::= while(Ausdruck, Anweisung+) Anweisung ::= in(Identifikator) Anweisung ::= out(Ausdruck) Ausdruck ::= Konstante| Identifikator| Arith_Konstante| Log_Konstante| op1(Ausdruck)| op2(Ausdruck, Ausdruck)

53 x := (x1. 3) als abstrakter Syntaxbaum nach Variante 2 assign x
x := (x1 * 3) als abstrakter Syntaxbaum nach Variante 2 assign x * x1 3 oder als Term assign(x, *(x1, 3))

54 Formale Beschreibungsmittel Vienna Definition Language (VDL)
Sprachelemente: Datenstrukturen: abstrakte Objekte Operationen: Selektion, Substitution Abstrakte Objekte Gegeben: nichtleere Menge elementarer Objekte E nichtleere Menge von Selektoren S

55 Abstraktes Objekt: Jedes elementare Objekt aus E ist ein abstraktes Objekt. a1,..., an seien abstrakte Objekte und s1,..., sn Selektoren aus S, wobei für i  j auch si  sj. Dann ist die Menge aller Paare <si : ai>, i=1,...,n ein abstraktes Objekt. Notation: (<s1 : a1>, ..., <sn : an>) Weitere abstrakte Objekte gibt es nicht.

56 Graphische Darstellung:
s1 s2 sn a a2 an Beispiel: E = {e1, ..., e4}, S = {, , }   e1      e3 e1 e2 e3

57 Lineare Notation: (< : e1>, < : (< : (< : e1>, < : e2>, < : e3>)>, < : e3>) >) Schachtelnotation:  e1    e1  e2  e3  e3

58 Operationen: Auswahloperation: Auswahl eines abstrakten Objekts aus einem gegebenen abstrakten Objekt anhand eines Selektors a = (<s1 : a1>, ..., < sn : an>), s Selektor ai , wenn s = si s(a) =   , sonst ( ist das leere abstrakte Objekt) Beispiel: a sei abstraktes Objekt aus obigem Beispiel. Dann (((a))) = e2 .

59 Substitution: Ein durch eine Selektorfolge bestimmtes abstraktes Objekt in einem gegebenem abstrakten Objekt wird durch ein neues abstraktes Objekt ersetzt. Notation: (a, b, c) a umzuformendes Objekt b Selektorfolge c einzufügendes Objekt Beispiel: a obiges abstraktes Objekt (a, .., ) = (< : e1>, < : (< : (< : e1>, < : e3>)>, < : e3>)>)

60 Darstellung der abstrakten Syntax durch die VDL
Vorgehensweise: Festlegung von Mengen elementarer Objekte und Selektoren bezogen auf die Programmiersprache Einführung von Klassen abstrakter Objekte Definition der Objektklassen durch Regeln (Mengengleichungen)

61 Beispiel: BPS Zu 1.: Mengen elementarer Objekte Konstante, Variable, op1 (monadische Operatoren), op2 (dyadische Operatoren) Zu 2.: Klassen abstrakter Objekte Ausdruck, monadischer_Ausdruck, dyadischer_Ausdruck, Anweisung, Vereinbarung,... Zu 3.: Regeln Ausdruck = Konstante|Variable|monadischer_Ausdruck| dyadischer_Ausdruck

62 Die Objektklasse Ausdruck ergibt sich als Vereinigung der Objektklassen Konstante, Variable, monadischer_Ausdruck und dyadischer_Ausdruck. monadischer_Ausdruck = (<op : op1>, <arg : Ausdruck>) Ein Element der Klasse monadischer_Ausdruck ist ein abstraktes Objekt mit der Struktur beschrieben auf der rechten Seite der Gleichung. Analog: dyadischer_Ausdruck = (<op : op2>, <arg1 : Ausdruck>, <arg2 : Ausdruck>)

63 Beispiel: abstraktes Objekt zu ((-(x/y)) + 1)
op arg1 arg2 + op arg 1 - op arg arg2 / x y (<op : +>, <arg1 : (<op : ->, <arg : (<op : />, <arg1 : x>, <arg2 : y>)>)>, <arg2 : 1>)

64 Darstellung der abstrakten Syntax durch die Vienna Development Method (VDM)
Elemente der Beschreibungssprache Meta IV (neue Bezeichnung: VDM-SL): :: Trennzeichen von linker und rechter Seite in Regeln zur Definition baumartiger Objekte = | Verwendung wie in VDL (K m L) Menge aller Funktionen mit dem Definitionsbereich K und dem Resultatsbereich L A* Menge aller endlichen Folgen von Objekten der Objektklasse A einschließlich der leeren Folge _ bezeichnet elementare Objekte

65 Beispiel: ausgewählte Regeln für BPS Programm :: Vereinbarungen Anweisung+ Objekt aus Objektfolge aus Vereinbarungen Anweisung (In VDL: Programm = (<decl : Vereinbarungen>, <stats : Anweisungen>) )

66 Vereinbarungen :: (Variable m Typ)
Endliche Funktion, die jedem Objekt aus der Klasse Variable ein Objekt aus der Klasse Typ zuweist. Typ = INT|BOOL Die Klasse Typ enthält die Objekte INT und BOOL. Anweisung = leere_Anweisung|Wertzuweisung| bedingte_Anweisung|Laufanweisung Die Klasse Anweisung ist eine Vereinigung der Klassen ...

67 leere_Anweisung :: SKIP Wertzuweisung :: Variable Ausdruck Variable :: Identifikator bedingte_Anweisung :: Ausdruck Anweisung+ Anweisung+ Laufanweisung :: Ausdruck Anweisung+ Ausdruck = ... Siehe VDL Klassen elementarer Objekte: Konstante, Identifikator, op1, op2, leere_Anweisung, Typ

68 Strukturelle Syntax (konkret und abstrakt)
Beispiel: BPS Syntaktische Kategorien Notation: v  M bedeutet, v vertritt ein beliebiges Objekt aus M ak  ArithKonstante lk  LogKonstante li  LogIdentifikator ai  AritIdentifikator aa  ArithAusdruck la  LogAusdruck ao1  ArithOperator1 ao2  ArithOperator2 lo1  LogOperator1 lo2  LogOperator2 vo  Vergleichsoperator an  Anweisung

69 Regeln (Auswahl) Axiome ak : ArithAusdruck ai : ArithAusdruck
Eine arithmetische Konstante ist ein arithmetischer Ausdruck. ai : ArithAusdruck Ein arithmetischer Identifikator ist ein arithmetischer Ausdruck. lk : LogAusdruck li : LogAusdruck

70 Schlussregeln aa : ArithAusdruck ao1 aa : ArithAusdruck
Ist aa ein arithmetischer Ausdruck, dann ist auch ein beliebiger unärer (monadischer) arithmetischer Operator gefolgt von aa ein arithmetischer Ausdruck. aa1 : ArithAusdruck aa2 : ArithAusdruck aa1 ao2 aa2 : ArithAusdruck la : LogAusdruck an1 : Anweisung an2 : Anweisung if la then an1 else an2 fi : Anweisung

71 3 Semantikdefinition Formale Methoden
Arten der Semantikdefinition: Vor.: P Menge der erlaubten Programmkonstrukte, p  P Operational: p  b1, ..., bn Befehlsfolge eines abstrakten Rechners z0 b1 z1 b2 ... bn zn Zustandsübergänge des abstrakten Rechners

72 Denotational: p  mathematisches Objekt Speziell: f  [C p C] Funktion zur Änderung von Variablenbelegungen C = [Variable  Wert] Menge der Variablenbelegungen Axiomatisch: p  {} p {} verallgemeinerte Formel, ,  logische Formeln mit geeigneter Interpretation

73 3.1 Operationale Semantik 3.1.1 Grundbegriffe
Maschine (abstrakter Rechner): M = (Z, T) mit Zustandsmenge Z und binärer Relation T (Übergangsrelation) auf Z (Befehle können als Bestandteil eines Zustands aufgefasst werden) Deterministische Maschine: Maschine mit partieller Übergangsfunktion

74 Berechnung auf einer Maschine:
Beliebige Zustandsfolge z0, z1,... , wobei zi T zi+1 (deterministisch: T(zi) = zi+1), i=0, 1,... Endzustand z: Es existiert kein Zustand z´ mit z T z´ (deterministisch: T(z) ist nicht definiert). Echte Berechnung: Unendliche Berechnung oder Endliche Berechnung, die auf einen Endzustand endet.

75 Ergebnisrelation: binäre Relation ResM, wobei z ResM z´  z0,
Ergebnisrelation: binäre Relation ResM, wobei z ResM z´  z0, ..., zn echte Berechnung mit z = z0 und z´= zn. (Bei deterministischen Maschinen existiert zu jedem z höchstens 1 echte Berechnung. ResM ist eine partielle Funktion.)

76 Allgemeine Vorgehensweise für operationale Semantikdefinition:
Definition der abstrakten Syntax der Programmiersprache Definition einer geeigneten abstrakten Maschine in Abhängigkeit von der Programmiersprache Zuordnung von Befehlsfolgen/Zustandsfolgen der abstrakten Maschine zu jedem Programmkonstrukt einschließlich kompletten Programmen

77 3.1.2 Operationale Semantikdefinition unter Nutzung der VDL
Definition der abstrakten Maschine – w-Maschine: Zustand (abstraktes Objekt im Sinne der VDL) s iz ev Steuerteil Innerer Zustand Umgebung

78 Steuerteil: enthält hierarchisch organisiert Anweisungen (Befehle) der w-Maschine mit abstrakten Programmteilen als Parameter Innerer Zustand: Zuordnung von Werten zu Adressen (Speicherbelegung) Umgebung: Zuordnung von Adressen zu Variablen (Speicherzuteilung zu Programmvariablen)

79 Zustandsübergänge: - Realisierung durch Ausführung von Anweisungen in den Blättern des Steuerteils (bei Vorhandensein aller Parameterwerte) - Endzustand: Zustand mit leerem Steuerteil - Fehlerzustand: keine Anweisung ist ausführbar und Endzustand wurde nicht erreicht

80 Beispiel: Abarbeitung der Wertzuweisung
x := (y * 3) aus BPS im Zustand mit x = 1 und y = 5 Startzustand s iz ev int-Ergibt   x y (´x:=(y*3)´)   ´x:=(y*3)´ bedeutet die abstrakte Repräsentation der Wertzuweisung;  und  sind Adressen; n repräsentiert Werte

81 Abarbeitung einer Wertzuweisung (Anweisung int-Ergibt mit abstrakter Struktur der Wertzuweisung als Parameter): Bestimmung der Adresse der Variablen der linken Seite Berechnung des Werts des Ausdrucks der rechten Seite Abspeicherung des berechneten Werts auf der bestimmten Adresse

82 Widerspieglung im Steuerteil:
int-Ergibt(´v:=A´)  subst(ad,w) ad: Adresse(´v´) w: int-Ausdr(´A´) Adresse(´v´) = v(ev(z)) Adressenbestimmung für Variable v subst(ad,w) = (z, ad(iz(z)), w) - Änderung des Werts (neuer Wert w) einer Variablen repräsentiert durch Adresse ad

83 Berechnung eines Ausdrucks (int-Ausdr):
Fall 1: Ausdruck ist Konstante k: int-Ausdr(´k´) = Wert(´k´) = k Fall 2: Ausdruck ist Variable v: int-Ausdr(´v´) = Inhalt(´v´) = v(ev(z))(iz(z)) (v(ev(z)) ist die Adresse von z) Fall 3: Ausdruck ist dyadischer Ausdruck: - Berechnung der Werte der Operanden - Verknüpfung der Operandenwerte durch entsprechende Operation

84 int-Ausdr(´A op2 B´)  c: int-op(´op2´, a, b)
a: int-Ausdr(´A´) b: int-Ausdr(´B´) (Berechnung von (Berechnung von Operand A) Operand B) Fall 4: Ausdruck ist monadisch: analog zu Fall 3

85 Arten von Anweisungen im Steuerteil:
Anweisungen zur Erzeugung von Werten: - Berechnung von Argumenten der Anweisungen an Vorgängerknoten bzw. Änderungen im inneren Zustand oder in der Umgebung - Entfernung des Knotens aus dem Steuerteil nach der Berechnung Anweisungen zur Entwicklung des Steuerteils (Aufgabenzerlegung in Teilaufgaben): Ersetzen des Knotens mit der Anweisung durch Baum mit Anweisungen

86 a: int-Ausdr(´y´) b: int-Ausdr(´3´)
Fortsetzung des Beispiels beginnend mit dem Startzustand (Verzicht auf inneren Zustand und Umgebung): int-Ergibt(´ x:=(y*3)´)  subst(ad,v)  ad: Adresse(´x´) v: int-Ausdr(´(y*3)´) subst(, v)  subst(, v) v: int-op(´*´, a, b) v: int-Ausdr(´(y*3)´) a: int-Ausdr(´y´) b: int-Ausdr(´3´)

87 subst(, v)  subst(, v)  v: int-op(´. ´, a, b) v: int-op(´
subst(, v)  subst(, v)  v: int-op(´*´, a, b) v: int-op(´*´, 5, b) a: Inhalt(´y´) b: int-Ausdr(´3´) b: int-Ausdr(´3´) subst(, v) subst(, v) subst(,15)   v: int-op(´*´, 5, b) v: int-op(´*´, 5,3) b: Wert(´3´)

88 Endzustand iz ev   x y  

89 3.1.3 Strukturelle operationale Semantik
Beispiel: BPS Zustände st(in, out, sto), wobei in Eingabedatei in Form einer Liste out Ausgabedatei in Form einer Liste sto: Variable  Wert Variablenbelegung im Zustand

90 Hilfsfunktionen: Listenmanipulation: head (erstes Element), tail (Restliste nach Entfernen des ersten Elements), append (Listenverkettung) Leere Variablenbelegung (Speicher-initialisierung): emptySto Speicheraktualisierung durch Zuweisung eines Wertes w zu einer Variablen v: updateSto(sto, v, w) = sto´, wobei sto´(v) = w und sto´(y) = sto(y) für alle y  v (Andere Notation: sto´= sto{v/w})

91 Bestimmung des Wertes einer Variablen v: applySto(sto, v) = w, wenn sto(v) = w
Berechnung von monadischen (unären) Ausdrücken: compute1(op1, arg) = w, wobei op1  ArithOperator1, arg ist der Wert des Operanden und w das Ergebnis der Berechnung Analog erfolgt die Berechnung dyadischer Ausdrücke durch compute2(op2, arg1, arg2) = w

92 Übergangsrelation: Nutzung von Konfigurationen und Regeln zur Beschreibung des Übergangs zwischen Konfigurationen Konfiguration: <Programmstück, Zustand> Übergang: <A, z>  <A´, z´> Beendigung des Übergangs: Erreichen einer Endkonfiguration <skip, z> Erreichen einer Konfiguration, in der keine Regel anwendbar ist

93 Regeln für BPS (Auswahl)
(1) Bestimmung des Wertes einer arithmetischen Variablen (syntaktisch identisch mit arithmetischem Identifikator) im Zustand st(_,_, sto): <ai, st(_,_,sto)>  <applySto(sto, ai), st(_,_, sto)> (Speicherbelegung wird nicht geändert) (2) Berechnung eines arithmetischen Ausdrucks, dessen Operanden als Konstanten, und damit wertmäßig, vorliegen: <ak1 ao2 ak2, st(_,_, sto)>  <compute2(ao2, ak1, ak2), st(_,_, sto)>, wobei (ao2  /) oder (ak2  0)

94 (3) Transformation arithmetischer Ausdrücke in die Form von Regel (2):
<aa1, st(_,_, sto)>  <aa1´, st(_,_, sto)> <aa1 ao2 aa2, st(_,_, sto)>  <aa1´ ao2 aa2, st(_,_, sto)> (4) Ausführung einer Wertzuweisung mit Konstante auf rechter Seite: <ai := ak, st(_,_, sto)>  <skip, st(_,_,update(sto, ai, ak))> (5) Einlesen eines Wertes von der Eingabedatei in und Zuweisung an eine Variable: <read ai, st(in,_, sto)>  <skip, st(tail(in),_, update(sto, ai, head(in)))> vorausgesetzt in  [ ]

95 (6) Transformation einer Wertzuweisung in die Form (4):
<aa, st(_,_, sto)>  <aa´, st(_,_, sto)> <ai := aa, st(_,_, sto)>  <ai := aa´, st(_,_, sto)> Beispiel: Berechnung von x := (y * 3) Vor.: x = 1, y = 5  sto0(x) = 1, sto0(y) = 5 Startkonfiguration: <x := (y * 3), st(_,_, sto0)> Betrachtung von < y * 3, st(_,_, sto0)>

96 Wertbestimmung für y nach Regel (1)
Betrachtung von <y, st(_,_, sto0)> Wertbestimmung für y nach Regel (1) <applySto(sto0, y), st(_,_, sto0)> Anwendung von Regel (3) <y, st(_,_, sto0)>  <5, st(_,_, sto0)> < y * 3, st(_,_, sto0)>  <5*3, st(_,_, sto0)> Anwendung von Regel (2) <5*3, st(_,_, sto0)>  <compute2(*, 5, 3), st(_,_, sto0)>

97 Anwendung von Regel (6) Anwendung von Regel (4)
< y * 3, st(_,_, sto0)>  <15, st(_,_, sto0)> <x := (y * 3), st(_,_, sto0)>  <x := 15, st(_,_, sto0)> Anwendung von Regel (4) <x := 15, st(_,_, sto0)>  <skip, st(_,_, sto1)>, wobei sto1 = updateSto(sto0, x, 15)

98 Probleme Konsistenz: Widerspruchsfreiheit der Regeln Vollständigkeit: Semantik kann entsprechend Realität ausgedrückt werden Hier: Konsistenz: Der durch die Regeln berechnete Wert eines Ausdrucks ist eindeutig bestimmt. Vollständigkeit: Hat ein Ausdruck einen Wert w, dann kann dieser durch die Regeln berechnet werden.

99 Behauptung: Alle Ausdrücke unserer Programmiersprache lassen sich durch die Regeln richtig berechnen, d.h. die Regeln sind konsistent und vollständig. Beweis: durch strukturelle Induktion: Eigenschaft gilt für Variablen und Konstanten Wenn die Eigenschaft für alle Operanden eines Ausdrucks gilt, dann gilt sie auch für alle daraus zusammengesetzten (erlaubten) Ausdrücke.

100 3.2 Denotationale Semantik Grundbegriffe
Prinzip: Baukastenprinzip  - Bedeutung komplexer Konstrukte ist aus Bedeutungen der Komponenten zusammengesetzt - Relativ isolierte Betrachtung der Bausteine möglich - Beweise durch strukturelle Induktion - Austauschbarkeit semantisch äquivalenter Bausteine

101 Vorgehensweise: Definition der syntaktischen Definitionsbereiche (Strukturen) Definition der semantischen Definitionsbereiche (Bedeutungen) Einführung funktionaler Operatoren zur Umsetzung des Baukastenprinzips (Kombination von Bedeutungen) Festlegung von Basisfunktionen Schrittweise Definition der Semantik elementarer und zusammengesetzter Programmkonstrukte

102 3.2.1 Denotationale Semantikdefinition am Beispiel BPS
Voraussetzung: Alle Programmkonstrukte sind syntaktisch korrekt und erfüllen die Kontextbedingungen. Syntaktische Definitionsbereiche (Auswahl) Ausdruck Anweisung Variable Konstante op1 op2

103 Semantische Definitionsbereiche Variablenwerte ℤ Menge der ganzen Zahlen WF = {W, F} Menge der Wahrheitswerte W (wahr) und F (falsch) W = WF  ℤ  {} Menge aller möglichen Variablenwerte einschließlich undefiniertem Wert  C = [Variable  W] Menge aller Variablenbelegungen

104 Bedeutungen von Ausdrücken und Anweisungen CW = [C  W] Menge aller Wertberechnungen von Ausdrücken in Abhängigkeit von den Variablenbelegungen S = [C p C] Menge aller Änderungen von Variablenbelegungen Beispiele: - c0  C mit c0 = {(x, -30), (y, 1), (z, ),...} , d.h. c0(y) = 1 usw.

105 (x + y)  Ausdruck  f  CW, wobei f eine gegebene Variablenbelegung (und damit die Werte für x und y) auf den Wert des Ausdrucks abbildet; also f(c0) = –29 . x := (x + y)  Anweisung  g  S, wobei g eine gegebene Variablenbelegung für die Variable x abändert; also g(c0) = c1. x hat nun den Wert des Ausdrucks, somit c1(x) = und c1(v) = c0(v) für v  x oder kürzer g(c0) = c0{x/-29} .

106 Basisfunktionen Den Operatoren von BPS werden die üblichen Operationen (Basisfunktionen) als Bedeutungen zugeordnet. Notation: unterstrichener Operator bedeutet die zugeordnete Operation Beispiel: +  op2  + Addition zweier integer- Zahlen Operator  zugeordnete Operation

107 Funktionale Operatoren Verkettung partieller Funktionen: f: A p B , g: B p C  f.g: A p C mit (f.g)(x) = g(f(x)), wenn f(x) und g(f(x)) definiert sind Auswahloperation: f: A p B , g: A p B, Bed: A p WF  ...  (Bed  f, g): A p B mit  f(a), wenn Bed(a) = W (Bed  f, g)(a) =  g(a), wenn Bed(a) = F  ? , sonst

108 Modifizierung: f: A p B , a  A, b  B  f{a/b}: A p B mit f{a/b}(a) = b und f{a/b}(x) = f(x) für x  a. Fixpunktoperator: У(f) liefert den kleinsten Fixpunkt der Funktionalgleichung f(x) = x. Voraussetzungen: s.u.

109 Semantikdefinition für ausgewählte Konstrukte Semantik von Ausdrücken
Wert: Ausdruck  CW Wert ordnet jedem Ausdruck als Bedeutung eine Funktion aus CW zu, d.h. Wert〚a〛 CW und Wert〚a〛(c)  W, a  Ausdruck, c  C. Bedeutung logischer Konstanten Wert〚true〛(c) = W Wert〚false〛(c) = F

110 Bedeutung von integer-Zahlen Wert〚n〛(c) = n , n integer-Zahl, c  C
Bedeutung von Variablen Wert〚x〛(c) = c(x) , x Variable, c  C Bedeutung monadischer und dyadischer Ausdrücke Wert〚(o E)〛(c) = o Wert〚E〛(c) Wert〚(E1 o E2)〛(c) = Wert〚E1〛(c) o Wert〚E2〛(c) E, E1, E2 Ausdrücke, c  C Beispiel: Wert〚(y + 3)〛(c0) = Wert〚y〛(c0) + Wert〚3〛(c0) = c0(y) + 3 = = 4

111 Semantik von Anweisungen SD: Anweisung  S
Jeder Anweisung wird als Bedeutung eine Funktion aus S zugeordnet, die die durch die Abarbeitung bewirkte Änderung der Variablenbelegung beschreibt; somit SD〚A〛S , SD〚A〛 (c)  C für A  Anweisung und c  C. Semantik der skip-Anweisung SD〚skip〛= Id , Id Identität auf C Die Ausführung der skip-Anweisung lässt Variablenbelegungen unberührt.

112 Semantik von Wertzuweisungen SD〚x := E〛(c) = c{x/ Wert〚E〛(c)} x  Variable, E  Ausdruck, c  C Durch die Abarbeitung der Wertzuweisung wird die ursprüngliche Variablenbelegung modifiziert. Die Variable der linken Seite bekommt als Wert den Wert des Ausdrucks der rechten Seite zugeordnet. Beispiel: SD〚x := (y + 3)〛(c0) = c0{x/ Wert〚(y + 3)〛(c0)} = c0{x/4} = c1 Folglich: c1(x) = 4 , c1(v) = c0(v) für v  x

113 Semantik der if-Anweisungen SD〚if B then A1 else A2 fi〛(c) = (Wert〚B〛 SD〚A1〛, SD〚A2〛)(c) Die Bedeutung einer if-Anweisung ist im regulären Fall die Bedeutung der Anweisungsfolge A1 oder der Anweisungsfolge A2 in Abhängigkeit vom Wahrheitswert des Ausdrucks (Bedingung). Beispiel: SD〚if (x > 0) then y := 1 else y := 0 fi〛= (Wert〚(x > 0)〛 SD〚y := 1〛, SD〚y := 0〛)

114 Semantik von Anweisungsfolgen SD〚A1 ; A2〛= SD〚A1〛. SD〚A2〛
A1, A2  Anweisung Anweisungsfolgen werden sequentiell abgearbeitet. Beispiel: SD〚x := (y – 1) ; y := (z + 25)〛= SD〚 x := (y – 1) 〛. SD〚 y := (z + 25)〛 SD〚 x := (y – 1) 〛 SD〚 y := (z + 25)〛 c0  c1  c2

115 Semantik der while-Anweisung SD〚while B do A od〛= SD〚 if B then A; while B do A od else skip fi 〛= (Wert〚B〛 SD〚A〛. SD〚while B do A od〛, Id)   = F() mit  = SD〚while B do A od〛 und F() = (Wert〚B〛 SD〚A〛. , Id) ,   S (*) Gesucht wird also eine Funktion aus S, die die Fixpunktgleichung (*) erfüllt.

116 Abarbeitung von while B do A od - Darstellung als Programmablaufplan
B nein ja A - Ablauf zeitlich gestreckt mit Variablenbelegungen c c c2 B nein B nein B nein c0 c c2 ja ja ja A A A c3

117 Abbruchsituationen: Abbruch nach der Bedingungsüberprüfung des ersten Durchlaufs wegen Nichterfüllung der Bedingung: Ergebnis ist Variablenbelegung c0 Abbruch nach der Bedingungsüberprüfung des (i+1)-ten Durchlaufs wegen Nichterfüllung der Bedingung: Ergebnis ist Variablenbelegung ci Abbruch wegen Fehlersituation: Ergebnis ist undefinierte Variablenbelegung Kein Abbruch (unendliche Schleife): Ergebnis ist undefinierte Variablenbelegung (sollte von Fall 3 unterschieden werden)

118  Eigenschaften der Lösungsfunktion . : undef
 Eigenschaften der Lösungsfunktion *: undef. c bei unendlicher Schleife *(c0) = ci , Wert〚B〛(cj) = W für j=0,1,...,i-1 und  Wert〚B〛(ci) = F c0 , Wert〚B〛(c0) = F ? , Fehlerabbruch

119 Fixpunktsatz Mathematische Grundlagen (Theorie der semantischen Bereiche von Scott)
Intuitive Vorstellung eines semantischen Bereichs: Als Träger Struktur mit Datenobjekten eines bestimmten Typs (endliche und unendliche Objekte) Berechnung unendlicher Objekte durch endliche Approximation

120 Beispiel: partielle einstellige Funktionen über natürlichen Zahlen (f: M p N, M  N) Endliche Objekte: Funktionen mit endlichem Definitionsbereich (M endlich) Unendliche Objekte: Funktionen mit unendlichem Definitionsbereich (M unendlich) Approximation (⊑): f approximiert g (f ⊑ g) genau dann, wenn gilt: Ist f(x) definiert, dann ist auch g(x) definiert und f(x) = g(x).

121 Endliche Datenobjekte: fn: N p N 2x, wenn 0  x  n mit fn(x) =  undef., sonst Daher: fn ⊑ fm für n,m  N und n  m Unendliches Datenobjekt: f*(x) = 2x , x  N Es gilt: ⊥ ⊑ f1 ⊑ f2 ⊑ f3 ⊑ ... ⊑ f*

122 Definition (semantischer Bereich im Sinne von cpo = complete partial order):
Eine Struktur A = (A, ⊑A) ist ein semantischer Bereich, wenn gilt: ⊑A ist eine Halbordnung auf der Trägermenge A In A existiert bzgl. ⊑A ein kleinstes Element ⊥A. Jede Kette K  A besitzt bzgl. ⊑A eine kleinste obere Schranke ∐K in A. (Kette = geordnete Menge)

123 Beispiele: N  {}  N mit ∞ ∞ . 2 1

124 Menge von Teilmengen der Menge {a, b, c}
{a, c} {a, b} {b, c} {b} {a} {c}  = 

125 Definition: A, B semantische Bereiche
f: A p B f ist monoton: Für alle a1, a2  A folgt aus a1 ⊑A a2 auch f(a1) ⊑B f(a2). f ist stetig: Für jede Kette K  A gilt, f(K) ist eine Kette und f(∐K) = ∐f(K). f ist strikt: f(A) = B. Notation: [A  B] semantischer Bereich aller Funktionen, die A in B abbilden, mit Approximation ⊑ als Halbordnung.

126 A semantischer Bereich, F  [A p A] stetig
Fixpunktsatz: A semantischer Bereich, F  [A p A] stetig Der kleinste Fixpunkt der Gleichung F() =  ist gegeben durch У(F) = ∐n=0∞ Fn(A) Anwendung für die while-Anweisung: -  = F() mit  = SD〚while B do A od〛 und F() = (Wert〚B〛 SD〚A〛. , Id) ,   S - F() = (Wert 〚B〛 SD〚A〛. , Id) = F1 - Fi+1()) = (Wert 〚B〛 SD〚A〛. Fi, Id)

127 C , Wert〚B〛(c0) = W für j=0,1,2,...
- Lösungsfunktion: C , Wert〚B〛(c0) = W für j=0,1,2,... ci , Es existiert ein i so, dass *(c0) =  Wert〚B〛(cj) = W für j=0,1,2,...,i-1  und Wert〚B〛(ci) = F c0 , Wert〚B〛(c0) = F ? , sonst

128 Semantik für Ein- und Ausgabeanweisungen
Wirkung der Eingabeanweisung read x, x  Variable: Lesen eines Wertes von einer Eingabedatei (mit Löschen) und Zuweisung zur Variablen Wirkung der Ausgabeanweisung write A, A  Ausdruck: Berechnung des Ausdrucks und Ausgabe auf eine Ausgabedatei Modellierung der Ein- und Ausgabedateien durch zwei interne Variablen Ein und Aus, wobei jeder Variablen eine Wertefolge zugeordnet ist: c(Ein)  W* , c(Aus)  W*

129 Denotationale Modellierung: SD〚read x〛(c) = c´, x  Variable, wobei gilt: 1. Wenn c(Ein) = w1 w2 ... wn , dann c´(Ein) = w2 ... wn (Fehler bei c(Ein) = ). 2. c´(x) = w1 3. c´(y) = c(y) für alle übrigen Variablen SD〚write A〛(c) = c´, A  Ausdruck, wobei gilt: 1. Wenn c(Aus) = w1 w2 ... wn , dann c´(Aus) = w1 ... wn Wert〚A〛(c) . 2. c´(y) = c(y) für alle übrigen Variablen.

130 Semantik von Vereinbarungen (hier für Variablen)
Wirkung der Variablenvereinbarungen: Information über die Eigenschaften der im Programm verwendeten Variablen Basis für Compileraktionen: Speicherplatzreservierung, Initialisierung Denotationale Umsetzung: c(x) = ? Variable x wurde noch nicht vereinbart c(x)  W Variable x wurde vereinbart und besitzt einen Wert aus W

131 Einführung einer Anfangsbelegung (Startzustand) c0 für ein Programm:
c0(x) = ? für x  Variable ( x ist nicht deklariert) c0(Ein) = w1 w2 ... wn  W* Eingabedatei c0(Aus) =  Ausgabedatei SD〚t x〛(c) = c´, x  Variable, t  Typ, wobei gilt: 1. c´(x) =  ( x ist deklariert) 2. c´(y) = c(y) für alle übrigen Variablen

132 Semantik von Programmen SD〚begin V; A end〛= (SD〚V〛. SD〚A〛
Semantik von Programmen SD〚begin V; A end〛= (SD〚V〛. SD〚A〛. SD1〚V〛) , V  Vereinbarung, A  Anweisung SD1 macht Anweisungen „rückgängig“: SD1〚t x〛(c) = c´, x  Variable, t  Typ, wobei gilt c´(x) = ? ( x ist nicht mehr deklariert)

133 Beispiel: begin int x; int y; V1 V2 read y; A1 x := (y – 5); A2 write x A3 end SD〚P〛= SD〚V1〛. SD〚V2〛. SD〚A1〛. SD〚A2〛. SD〚A3〛. SD1〚V1〛. SD1〚V2〛 Anfangsbelegung: c0(Ein) = -3 c0(Aus) =  c0(x) = c0(y) = ?

134 c Ein Aus x y Sem. Funktion c0 -3 . SD〚int x〛 c1 -3  
c Ein Aus x y Sem. Funktion c0 -3  ? ? SD〚int x〛 c1 -3   ? SD〚int y〛 c2 -3    SD〚read y〛 c3    -3 SD〚x := (y – 5)〛 c4   SD〚write x〛 c5  SD1〚int x〛 c6  -8 ? -3 SD1〚int y〛 c7  -8 ? ?

135 Denotationale Semantik für eine Erweiterung von BPS
Blockkonzept Syntax: <Anweisung> ::= <Block> <Block> ::= begin <Vereinbarungen>;<Anweisungen> end

136 Rolle von Blöcken: Einführung eines neuen Vereinbarungsniveaus Beschränkung der Lebensdauer von Objekten auf den Block Beschränkung der Zugriffsrechte: neu vereinbarte Identifikatoren verdecken bis zum Blockende das bisher mit dem Identifikator verbundene Objekt Identifikationsprozess für Identifikatoren: Zu jedem angewandten Auftreten eines Identifikators Suche des definierenden Auftretens zunächst im Block des angewandten Auftretens und bei Fehlen im unmittelbar umfassenden Block; Fortsetzung des Prozesses bis zum Erfolg oder, bis der Misserfolg sicher ist.

137 Beispiel: Ik(x, y) bedeutet eine Anweisungsfolge mit x und y 1: begin int x; int y; I1(x, y); 2: begin bool y; I2(x, y); 3: begin int x; I3(x, y) end; I4(x, y); 4: begin int y; I5(x, y) I6(x, y) I7(x, y) end

138 Realisierung des Blockkonzepts:
Allgemein: Umgebungskonzept zur Zuordnung von Objekten zu Identifikatoren Hier: Orientierung an der Verwendung von Kellerspeichern für die Datenverwaltung in Compilern  1. Erweiterung der Funktionen c aus C: c: Variable  {Ein, Aus}  W* mit c: Variable  W+ , wobei c(x) = ? x ist nicht vereinbart c(x) = w1 w2 ... wn w1 Wert im sichtbaren Block wi, i > 1, Werte in umfassenden Blöcken

139 Beispiel: Programm siehe obiges Beispiel Belegung von y in I5: c(y) = w1 w2 w3 , wobei w1 der Wert in I5, w2 der Wert am Ende von I4 und w3 der Wert am Ende von I1 sind 2. Verlängerung der Wertefolge einer Variablen von links um 1 Element beim Auftreten des Identifikators in einer Vereinbarung: SD〚t x〛(c) = c´, x  Variable, t  Typ, wobei gilt: - Wenn c(x) = ?, dann c(x) =  . - Wenn c(x) = w1 w2 ... wn , dann c(x) =  w1 w2 ... wn.

140 3. Arbeit nur mit dem ersten Element der Wertefolge: - SD〚x := E〛(c) = c´ , x  Variable, E  Ausdruck, wobei gilt: Wenn c(x) = w1 w2 ... wn , dann c´(x) = Wert〚E〛(c) w2 ... wn . Analog: SD〚read x〛 - Wert〚x〛(c) = [c(x)]1 , x  Variable

141 4. Verkürzung der Wertefolge einer Variablen von links um 1 Element beim Verlassen eines Blocks mit definierendem Auftreten der Variablen: SD1〚t x〛(c) = c´, x  Variable, t  Typ, wobei gilt: - Wenn c(x) = w , dann c´(x) = ? . - Wenn c(x) = w1 w2 ... wn , dann c´(x) = w2 ... wn . 5. Semantik von Programmen oder Blöcken: SD〚begin V; A end〛= (SD〚V〛. SD〚A〛. SD1〚V〛) , V  Vereinbarung, A  Anweisung

142 Beispiel: begin int x; int y; V1 V2 B1 read y; A1 x := (y – 5); A2 begin bool x; read y; V3 A3 B2 x := (y > 0); A4 write x A5 end; y := x; A6 write y A7 end

143 Anfangsbelegung: c0(Ein) = -3 0 c0(Aus) =  c0(x) = c0(y) =
Anfangsbelegung: c0(Ein) = -3 0 c0(Aus) =  c0(x) = c0(y) = ? SD〚B1〛= SD〚V1〛. SD〚V2〛 . SD〚A1〛 . SD〚A2〛 . SD〚B2〛 . SD〚A6〛 . SD〚A7〛 . SD1〚V1〛 . SD1〚V2〛 SD〚B2〛= SD〚V3〛. SD〚A3〛. SD〚A4〛. SD〚A5〛. SD1〚V3〛

144 c Ein Aus x y Sem. Funktion c0 -3 0 . SD〚V1〛 c1 -3 0  
c Ein Aus x y Sem. Funktion c  ? ? SD〚V1〛 c   ? SD〚V2〛 c    SD〚A1〛 c3 0   -3 SD〚A2〛 c4 0  SD〚V3〛 c5 0   SD〚A3〛 c6    -8 0 SD〚A4〛 c7   F -8 0 SD〚A5〛 c8  F F -8 0 SD1〚V3〛 c9  F -8 0 SD〚A6〛

145 c Ein Aus x y Sem. Funktion c10  F SD〚A7〛 c11  F SD1〚V1〛 c12  F -8 ? -8 SD1〚V2〛 c13  F -8 ? ?

146 Vektoren Voraussetzung: Der kleinste Index wird mit 1 festgesetzt und der größte durch eine Konstante in der Vereinbarung angegeben. Syntax: <Vereinbarung> ::= array [<Konstante>] <Typ> <Variable> ::= <Identifikator>[<Ausdruck>] Realisierung: Vektor x als endliche Funktion V V:{1, ..., Konstante}  W

147 Beispiel: x = (x1 x2 x3) = (1 7 -5) Als Funktion: x = {(1, 1), (2, 7), (3, -5)} Bezeichnung: VEKTOR bedeute im Weiteren die Menge aller endlichen Abbildungen dieser Art Erweiterung der Funktionen c aus C: c(x)  {W  VEKTOR}+, x  Variable, d.h. c(x) = wv1 ... wvn mit wvi  W  VEKTOR

148  Wert〚x(E)〛(c) = [c(x)]1(Wert〚E〛(c) ) = wv1(Wert〚E〛(c))
wvi  VEKTOR heißt, x wurde auf dem i-ten Deklarationsniveau als Vektor vereinbart und wvi ist demzufolge eine endliche Abbildung, die den Indizes Werte zuordnet (Vektorkomponenten).  Wert〚x(E)〛(c) = [c(x)]1(Wert〚E〛(c) ) = wv1(Wert〚E〛(c)) mit c(x) = wv1 ... wvn . Beispiel: v = {(1, 1), (2, 7), (3, -5)}, c(x) = v Wert〚x(2)〛(c) = [c(x)]1(Wert〚2〛(c) ) = v(2) = 7

149 SD〚array [k] t x〛(c) = c´, K Konstante, T Typ, x Variable, wobei gilt: 1. Wenn c(x) = ?, dann c´(x) = v mit v = {(1, ), (2, ), ..., (k, )}. 2. Wenn c(x) = w1 ...wn , dann c´(x) =v w1 ...wn mit v = {(1, ), (2, ), ..., (k, )}.

150 SD〚x[E1] := E2〛(c) = c´, E1,E2  Ausdruck, wobei gilt:
Wenn [c(x)]1 = v  VEKTOR, dann [c´(x)]1 = v´  VEKTOR und - v´(Wert〚E1〛(c)) = Wert〚E2〛(c) (Setzen der Komponente Wert〚E1〛(c) des Vektors x auf den Wert Wert〚E2〛(c)) - v´(i) = v(i) für i = 1, ..., k , i  Wert〚E1〛(c) (restliche Komponenten bleiben unverändert) - c´(y) = c(y) für y  x (restliche Variablen bleiben unverändert)

151 Beispiel: c(i) = 2 , c(x) = v w1
Beispiel: c(i) = 2 , c(x) = v w1 ...wn mit v = {(1, 1), (2, 7), (3, -5)}, SD〚x[i] := 0〛(c) = c´, wobei c´(x) = v´ w1 ...wn mit v´ = {(1, 1), (2, 0), (3, -5)},

152 Axiomatische Semantik
Charakterisierung und Ziele: Abstraktion vom Berechnungsverlauf Formulierung von Aussagen über Programmen und Teilprogrammen Ableitung von Programmeigenschaften, z.B. Korrektheit Ableitung korrekter Programme

153 Formulierung von Aussagen: Verallgemeinerte Formel {} P {} , (
Formulierung von Aussagen: Verallgemeinerte Formel {} P {} , (*) ,  logische Formeln, P Programmstück Logische Formel Interpretation Aussage Verallgemeinerte Formel Interpretation von (*) (partielle Korrektheit): Wenn vor der Ausführung von P  (interpretiert) galt und die Ausführung von P terminiert, dann gilt danach  (interpretiert).

154 Fragen: Welche „Formulierungssprache“ verwenden wir für  und ? Wie setzen sich Aussagen zu komplexen Programmfragmenten aus Aussagen der Komponenten zusammen? Wie lassen sich Programmeigenschaften beschreiben oder ableiten? Wie sind ,  und {} P {} zu interpretieren?

155  Komponenten der axiomatischen Semantik:
Abstrakte Syntax der Programmiersprache Logisches System (L, A, R), L Sprache des Systems, A  L Axiome, R Schlussregeln Axiome und Schlussregeln zu Eigenschaften der Programmiersprache Geeignete Interpretation für das logische System In imperativen Sprachen wird als logisches System i.d.R. die Prädikatenlogik erster Stufe verwendet.

156 Symbolmengen in der Prädikatenlogik:
V Menge von Individuenvariablen Fm Menge von m-stelligen Funktionssymbolen (m = 0: Individuen- konstanten) true, false Pm, m = 1, 2, Menge von m-stelligen Prädikatsymbolen {, , , , ⌝, ∀, ∃} logische Operationssymbole und Quantifikatoren ( ) , Hilfssymbole (unvollständig)

157 Terme (TR): V  TR, F0  TR f  Fm , t1,..., tm  TR  f(t1,..., tm )  TR Keine anderen Elemente sind aus TR. Formeln (FR): true, false  FR q  Pm , t1,..., tm  TR  q(t1,..., tm )  FR ,   FR, x  V ⌝,   ,   ,   , ∀x, ∃x, (),     FR Keine anderen Elemente sind Formeln.

158 Verallgemeinerte Formel: {} P {} , ,  logische Formeln, P Programmstück

159 Axiomatische Semantik von BPS
Gegeben: geeignete abstrakte Syntax Axiome und Schlussregeln nach Hoare (Auszug) Axiom der skip-Anweisung: {} skip {} (Die skip-Anweisung verändert Programmeigenschaften nicht.)

160 Axiom für die Wertzuweisung V := E (V Variable, E Ausdruck): {P’} V := E {P} , wobei P’ aus P durch Ersetzen der nichtquantifizierten Auftreten von V durch E entsteht (P’ ist die schwächste Vorbedingung; P’ = P[V/E]) Verkettungsregel für Anweisungen A1 und A2: {P} A1 {Q}, {Q} A2 {R} {P} A1; A2 {R}

161 Regel für die while-Anweisung: {PB} A {P} {P} while B do A od {P not B} P Schleifeninvariante Regel für die if-Anweisung: {  B} A1 {}, {  ⌝B} A2 {} {} if B then A1 else A2 fi {} Implikationsregeln: {P} S {Q}, Q  R P  R, {R} S {Q} {P} S {R} {P} S {Q}

162 Ableitung von Eigenschaften
Begriff des Theorems: Eine (verallgemeinerte) Formel  ist ein Theorem, wenn für  ein Beweis 0, 1,..., n existiert, wobei n =  und für i = 0, 1,..., n ist i entweder ein Axiom oder die Schlussfolgerung einer Schlussregel, deren Komponenten der Voraussetzung in 0, 1,..., i-1 enthalten sind. Notation: ⊢ 

163 Interpretation von (verallgemeinerten) Formeln Beweise sind syntaktische Manipulationen unter Verwendung eines Axiomen- und Schlussregelsystems. Inwieweit drücken die bewiesenen Formeln wirkliche Eigenschaften unserer Programmfragmente aus?  Notwendigkeit einer geeigneten Interpretation

164 x  y Interpretation Die Werte der Integer-
Beispiel: x  y Interpretation Die Werte der Integer- variablen x sind Interpretation größer oder gleich den Werten der Integer- Größer-Gleich- Integervariablen y. variablen Vergleich für mit best. Integerwerte Belegungen Wahre oder falsche Aussage in Abhängigkeit von den Belegungen für x und y.

165 Beispiel: { a > 0} a := (a – 1) {a  0} Interpretation
Der Wert der Integer- Der Wert der Integervariablen a Variablen a ist vor der ist nach der Abarbeitung der Abarbeitung der Zuweisung größer oder gleich 0. Zuweisung größer als 0. Wenn die Variablenbelegung vor Abarbeitung der Zuweisung a einen Wert größer als 0 zuordnet und die Abarbeitung terminiert, dann ordnet die durch die Zuweisung neu entstandene Variablenbelegung a einen Wert größer oder gleich 0 zu.

166 Interpretation (I) im Sinne der denotationalen Semantik
Bemerkung: Ausdrücke in BPS und logische Terme werden gleichgesetzt. Konstantensymbol (≙ Individuenkonstante) k: kI(c) = Wert〚k〛(c) = k (Die Interpretation kI einer Konstanten k bei beliebiger Variablenbelegung c liefert ihren Wert k.) Variable x: xI(c) = Wert〚x〛(c) = c(x)

167 Funktionssymbol f  Fm: fI ist eine m-stellige Operation Beispiel: +I ist die Addition zweier Integerwerte Term t: tI(c) = Wert〚t〛(c) Prädikatsymbol p: pI ist ein m-stelliges Prädikat Beispiel: <I ist der Kleiner-Vergleich zweier Integerwerte Programmfragment P: PI = SD〚P〛 (Die Interpretation eines Programmfragments ist seine denotationale Bedeutung.)

168 Formel : I  [C p WF] , wobei gilt:
(q(t1, ..., tm))I(c) = qI(t1I(c), ..., tmI(c)) , q  Pm , t1, ..., tm  TR Beispiel: (x > 0)I(c) = c(x) >I 0 (⌝ )I(c) = W  I(c) = F ,   FR Beispiel: (⌝ (y > 0))I(c) = W  (c(y) >I 0) = F (  )I(c) = F  I(c) = I(c) = F , ,   FR (   )I(c) = W  I(c) = I(c) = W , ,   FR

169 (  )I(c) = F  I(c) = W, I(c) = F , ,   FR
(∀x)I(c) = W  I(c´) = W für alle c´, die sich von c höchstens für x unterscheiden,   FR (∃x)I(c) = W  es existiert c´, das sich von c höchstens für x unterscheidet, und I(c´) = W Verallgemeinerte Formel {} P {}: - Partielle Korrektheit: ({} P {})I(c) = W  (I(c) = W, SD〚P〛(c) = c´ I(c´) = W)

170 - Totale Korrektheit: ({} P {})I(c) = W  (I(c) = W  SD〚P〛(c) = c´, I(c´) = W) Beispiel: ({a > 0} a := (a – 1) {a  0})I (c) = W  (c(a) >I 0) = W, SD〚a := (a – 1)〛(c) = c´ = c{a/Wert〚a – 1〛(c)} = c{a/(c(a) – 1)}  (c´(a) I 0) = W)

171 Notation: ⊨I (c) Eine (verallgemeinerte) Formel ist unter der Interpretation I bei Variablenbelegung c wahr (I(c) = W). ⊨I   ist für jede Variablenbelegung wahr (I ist ein Modell für ).

172 Probleme:  sei eine beweisbare (verallgemeinerte) Formel (Theorem), d.h. aus dem gegebenen Axiomen- und Schlussregelsystem ableitbar (⊦ ). Existiert ein Modell für , d.h. eine Interpretation I so, dass I(c) = W für alle c? Notation: ⊦   ⊨I  ? (Widerspruchsfreiheit, Konsistenz, Korrektheit des Axiomen- und Schlussregelsystems, Soundness)

173 A sei eine wahre Aussage über ein Programmfragment P.
Existiert zu P eine beweisbare verallgemeinerte Formel , deren Interpretation A liefert? Notation: ⊨I   ⊦  (Vollständigkeit, Completeness) Satz: Das Hoaresche Axiomen- und Schlussregelsystem ist für Pascal-ähnliche Sprachen widerspruchsfrei aber nicht vollständig.

174 Weitere Semantikarten Aktionssemantik (P. Mosses)
Ziele: Praktisch nützliche Semantikdefinition für realistische Programmiersprachen Kombination von Formalismus und guten praktischen Elementen Spracherweiterung ohne Neuformulierung alter Konstrukte Wiederverwendbarkeit der Bausteine (Kompositionalität) Gute Lesbarkeit und Verständlichkeit

175 Aktion: Element der Datenverarbeitung
 Elementare Aktionen, zusammengesetzte Aktionen (Kombination entsprechend algebraischen Gesetzen  Ableitung von Eigenschaften) Beispiele: Wert eines Identifikators evaluate I: Identifier = give the value bound to I or give the number stored in the cell bound to I

176 Semantik einer Anweisungsfolge
execute 〚S1: Statement ´´;´´ S2: Statement〛= execute S1 and then execute S2. Semantik der Wertzuweisung execute 〚I: Identifier ´´:=´´ E: Expression〛= (give the cell bound to I and evaluate E) then store the given number 2 in the given cell 1.

177 Gemeinsame Beschreibungsmittel für Syntax und Semantik
VDL: Beschreibung von abstrakter Syntax und operationaler Semantik Deduktive Regeln: Beschreibung einer strukturellen Syntax und einer strukturellen operationalen Semantik Problem: Darstellung der Kontextbedingungen (statische Semantik) Möglich z.B. durch partielle Semantikfunktionen oder über erweiterte kontextfreie Grammatiken

178 Verallgemeinerung kontextfreier Grammatiken - Zweistufengrammatik
Beispiel (modifizierte Notation): <start> ::= <a hoch N> <b hoch N> <c hoch N> <a hoch Ni> ::= a <a hoch N> <b hoch Ni> ::= b <b hoch N> <c hoch Ni> ::= c <c hoch N> <a hoch i> ::= a <b hoch i> ::= b <c hoch i> ::= c Definierte Sprache L: unter der Voraussetzung, dass L(N) = {i}* , ist L = {anbncn| n  1}

179 Komponenten von Zweistufengrammatiken:
Hyperregeln: können als parametrisierte kontextfreie Syntaxregeln oder als Regelmuster für kontextfreie Regeln betrachtet werden, wobei die Nichtterminale durch Hyperbegriffe ersetzt wurden Beispiel: <a hoch Ni> ::= a <a hoch N> ist eine Hyperregel mit den Hyperbegriffen <a hoch Ni> und <a hoch N> sowie dem Parameter (Metabegriff) N Metabegriffe: spielen die Rolle der Parameter in den Hyperregeln

180 Metaregeln: sind kontextfreie Syntaxregeln, deren Erzeugungen die Definitionsbereiche der Parameter (aus Metabegriffen abgeleitete Sprachen) festlegen Beispiel: Der Definitionsbereich von N im obigen Beispiel ist L(N) = {i}* , d.h. die Menge aller natürlichen Zahlen im Einersystem. Diese Sprache könnte nun durch kontextfreie Metaregeln beschrieben werden: N  | Ni

181 Erzeugung von Wörtern:
Ableitung von kontextfreien Syntaxregeln aus den Hyperregeln durch konsistentes Ersetzen der Metabegriffe (Parameter) durch aus ihnen abgeleitete Wörter (Wertebereiche der Parameter) Beispiel: aus obigen Regeln abgeleitete Regeln 1´ <start> ::= <a hoch iii> <b hoch iii> <c hoch iii> (N wurde durch iii in Regel 1 ersetzt) 2´ <a hoch iii> ::= a <a hoch ii> (N wurde durch ii in Regel 2 ersetzt) 2´´ <a hoch ii> ::= a <a hoch i> (N wurde durch i in Regel 2 ersetzt) Analog könnten 3´, 3´´, 4´ und 4´´ abgeleitet werden.

182 Wortableitung unter Verwendung der erzeugten kontextfreien Regeln
Beispiel: Erzeugung von a a a b b b c c c <start> 1´ <a hoch iii> <b hoch iii> <c hoch iii> 2´ a <a hoch ii> <b hoch iii> <c hoch iii> 3´,4´ a <a hoch ii> b<b hoch ii> c<c hoch ii> 2´´,3´´,4´´ a a<a hoch i> b b<b hoch i> c c<c hoch i> 5,6,7 a a a b b b c c c

183 Darstellung von Kontextbedingungen (prinzipiell):
Nutzung des Prinzips der konsistenten Ersetzung eines Parameters innerhalb einer Hyperregel Beispiel: <Ausdruck: T> ::= <Ausdruck: T> + <Ausdruck: T> L(T) = {int, real} Der +-Operator verknüpft entweder zwei Integerausdrücke oder zwei Realausdrücke zu einem Integerausdruck bzw. Realausdruck.

184 Nutzung spezieller Hyperbegriffe mit Erzeugung des leeren Wortes (primitive Prädikate)
Beispiel: Die Gleichheit zweier Buchstaben kann durch das Prädikat <where X is identical with Y> zusammen mit der Hyperregel <where X is identical with X> ::=  (*) und den Definitionsbereichen für X und Y L(X) = L(Y) = {a, b, ..., z} definiert werden.

185 Mögliche Fälle: 1. X und Y vertreten den gleichen Buchstaben, z.B. i. Dann kann aus der Hyperregel (*) die kontextfreie Regel <where i is identical with i> ::=  abgeleitet werden. 2. X und Y vertreten unterschiedliche Buchstaben, z.B. k und l. Es kann zwar <where k is identical with l> aber keine kontextfreie Regel abgeleitet werden. Das abgeleitete Nichtterminal ist eine Sackgasse.  Die Erzeugung des leeren Wortes signalisiert Erfüllung und eine Sackgasse Nichterfüllung einer Eigenschaft.

186 Beispiel: Erfüllung der Kontextbedingung:
In der gleichen Vereinbarungsfolge darf ein Identifikator höchstens einmal vereinbart werden. Vorgehen: Erstellung einer kontextfreien Grammatik zur Erzeugung von Vereinbarungsfolgen Einführung von Parametern: - TABLE: steht für eine Tabelle aller vereinbarten Identifikatoren zusammen mit ihrem Typ - ENTRY: symbolisiert einen Eintrag in der Tabelle und besteht aus einem Identifikator (ID) zusammen mit seinem Typ (TYPE) Einführung eines Prädikats für die Kontextbedingung (<where ENTRY is not in TABLE>)

187 Einführung von Hilfsprädikaten (z.B. <where ID is not ID1>)
Definition der Parameterwerte durch kontextfreie Syntaxregeln oder durch kontextfreie Sprachen Hyperregeln (Auszug) 1 <declaration list with ENTRY TABLE> ::= var <variable declaration with ENTRY> ; <dec list with TABLE> <where ENTRY is not in TABLE> 2 <dec list with ENTRY TABLE> ::= <variable declaration with ENTRY> ; <dec list with TABLE> 3 <dec list with > ::= 

188 4 <variable declaration with ID and TYPE> ::= <type with TYPE> <identifier with ID> 5 <type with bool> ::= bool 6 <type with int> ::= int 7 <where ENTRY is not in > ::=  8 <where ID and TYPE is not in ID1 and TYPE1> ::= <where ID is not ID1> 9 <where ENTRY is not in ID and TYPE TABLE> ::= <where ENTRY is not in ID and TYPE> <where ENTRY is not in TABLE> Mit Hilfe abgeleiteter Regeln lässt sich var int x; bool y; erzeugen, aber nicht var int x; bool x; (Sackgasse <where x is not x>)

189 Zweistufengrammatiken können auch genutzt werden um Operationen über ihre Eigenschaften (vergl. ADT) zu definieren. Beispiel: Multiplikation natürlicher Zahlen Eigenschaften: a * b = c  a * (b – 1) = c – a a * 0 = 0 Umsetzung in Hyperregeln: < NL1 N ist N mal NL2 i> ::= <NL1 ist N mal NL2> <NULL ist N mal NULL> ::=  L(NULL) = {} L(N) = {i}+ L(NL1) = L(NL2) = L(N)  {}

190 Charakteristika von Zweistufengrammatiken:
Kontextfreie Grammatiken mit parametrisierten syntaktischen Elementen Definitionsbereiche der Parameter: kontextfreie Sprachen (beschrieben durch eine kontextfreie Grammatik – Metagrammatik) Ableitungsbegriff: - Ableitung kontextfreier Syntaxregeln aus den Hyperregeln - Nutzung der abgeleiteten Regeln zur Spracherzeugung Mächtigkeit: Definition von Typ-0-Sprachen

191 Vor- und Nachteile von Zweistufengrammatiken:
+ Möglichkeit der kompletten Beschreibung einer Programmiersprache - Zu allgemein, nicht ausführbar, schwer sinnvoll einschränkbar  Entwicklungen für praktische Anwendungen: Affixgrammatiken, CDL, GSF, Erweiterte Affixgrammatiken

192 Attributierte Grammatiken
Beispiel (nach Irons): a =:: letter  {Ax} b =:: letter  {Bt} letter =:: iden  {P1} iden letter =:: iden  {P1 P2‖t  m‖} iden =:: sinnvar  {P1 ‖x  y‖} (iden =:: sinnvar  {₤1 ‖ P1‖})

193 Attributierte Grammatik nach Knuth Definition
Kontextfreie Basisgrammatik B = (N, T, P, S) mit Nichtterminalen N, Terminalen T, Startsymbol S und Regelmenge P X  N: A(X) = Ae(X)  As(X), Ae(X)  As(X) =  A(X) Attributmenge zu X Ae(X) (As(X)) ererbte (synthetisierte) Attribute zu X A(X) = As(X) für X = S und X  T a  A(X): Da Definitionsbereich von a p: X0  X1 X2 ...Xn a(Xi), a  A(Xi) Auftreten des Attributs a beim Element Xi in der Regel p (auch Xi.a)

194 Menge semantischer Regeln Fp zur Regel p:
Für alle a  As(X0): a(X0) = fpa,0(aa01,..., aa0ka), aa01,..., aa0ka A(p) = Uni=0 A(Xi) Für alle a  Ae(Xi), i=1,...,n: a(Xi) = fpa,i(aai1,..., aaika), aai1,..., aaika A(p) = Uni=0 A(Xi) Definierte Attribute einer Regel p: As(X0), Ae(Xi), i=1,...,n Angewandte Attribute einer Regel p: Ae(X0), As(Xi), i=1,...,n Eingabe/Abhängigkeitsmenge von a: {aai1,..., aaika} Attributierte Grammatik in Normalform: Eingabemengen enthalten nur angewandte Attribute

195 Synthetisierte Attribute Ererbte Attribute Fq Fp

196 Beispiel (Knuth) Basisgrammatik (Struktur der Binärzahlen) 1: B  0 einzelne Binärziffer 2: B  1 3: L  B Folge von Binärziffern 4: L1  L2B 5: N  L ganze Binärzahl 6: N  L1.L2 gebrochene Binärzahl

197 Beispiel (Knuth) - Fortsetzung
Semantische Regeln F1: b(B) := 0 F2: b(B) := 2p(B) F3: b(L) := b(B) l(L) := 1 p(B) := p(L) F5: b(N) := b(L) p(L) := 0

198 Beispiel (Knuth) - Fortsetzung
Semantische Regeln F4: b(L1) := b(L2) + b(B) p(B) := p(L1) p(L2) := p(L1) + 1 l(L1) := l(L2) + 1 F6: b(N) := b(L1) + b(L2) p(L1) := 0 p(L2) := -l(L2)

199 Beispiel (Knuth) – Abhängigkeitsgraphen
D(1): p B b D(2): p B b D(3): p L l b D(5): N b 1 p B b p L l b

200 Beispiel (Knuth) – Abhängigkeitsgraphen
D(4): p L l b p L l b p B b D(6): N b . p L l b p L l b

201 Beispiel (Knuth) – Abhängigkeitsrelation
N b p L l b p L l b p L l b p B b p L l b p B b p B b p B b

202 Attributierte Grammatiken Anwendung in Compiler-Compilern
Compilerbeschreibung in Form einer attributierten Grammatik: - Syntax der Programmiersprache als kontextfreie Basisgrammatik - Statische und dynamische Semantik durch Attribute und semantische Regeln Automatische Compilererzeugung durch Compiler-Compiler

203 Arbeitsweise des erzeugten Compilers:
Erzeugung eines (abstrakten) Syntaxbaums Dekorierung des Syntaxbaums durch Attributwerte unter Verwendung eines geeigneten Berechnungsalgorithmus´ (muss die durch die Attributabhängigkeiten induzierte Halbordnung beachten)

204 Beispiel – Statische Semantik von BPS´ (Ausschnitt)
<Ausdruck> ::= <Konstante> Typ(<Ausdruck>) := Typ(<Konstante>) <Ausdruck> ::= <Variable> Typ(<Ausdruck>) := Symtab (Tabelle(<Ausdruck>), Text(<Variable>) <Ausdruck>0 ::= (<op1> <Ausdruck>1) Tabelle(<Ausdruck>1) := Tabelle(<Ausdruck>0) Typ(<Ausdruck>0) := if Typ(<Ausdruck>1) = „int“ then „int“ else „undef“ fi

205 Tabelle(<Ausdruck>1) := Tabelle(<Ausdruck>0)
<Ausdruck>0 ::= (<Ausdruck>1 <op1> <Ausdruck>2) Tabelle(<Ausdruck>1) := Tabelle(<Ausdruck>0) Tabelle(<Ausdruck>2) := Tabelle(<Ausdruck>0) Typ(<Ausdruck>0) := Typ(Art(<op2>), Typ(<Ausdruck>1), Typ (<Ausdruck>2)) <op1> ::= +|- <op2> ::= +|-|/|* Art(<op2>) := „arit“ <op2> ::= =||| Art(<op2>) := „Vergl“ <op2> ::= || Art(<op2>) := „log“

206 Attributierte Grammatiken Praktische Probleme
Reihenfolge der Berechnung der Werte der Attributauftreten  effiziente Berechnungsalgorithmen Vermeidung/Detektion von Zyklen der Attributabhängigkeiten  Einschränkungen in der Definition Speicherplatzbedarf für semantische Bäume  Vermeidung der kompletten Abspeicherung

207 S-attributierte Grammatik
Besitzt ausschließlich synthetisierte Attribute  Berechnung der Attribute von den Blättern zur Wurzel unter Nutzung der Kellertechnik Jede zyklenfreie attributierte Grammatik kann in eine äquivalente S-attributierte Grammatik transformiert werden. Beachte Analogie zu YACC (Bison) – Grammatiken!

208 Berechnungsalgorithmus im Einpassverfahren
Voraussetzung: Alle ererbten Attribute von u sind berechnet; p: X0  X1 ...Xnp, vp = vp(1),..., vp(np) procedure eval(u); begin for i := 1 to np do berechne alle ererbten Attribute von u.vp(i); eval(u.vp(i) od; berechne alle synthetisierten Attribute von u end

209 Spezialfall: vp = 1,..., np e0 X0 s0 e1 X1 s1 e2 X2 s2 enp Xnp snp eval(u) eval(u.1), ..., eval(u.np)