Semantik von Programmiersprachen Theorie und Anwendungen (Informatik III, Wintersemester 03/04)

Transkript

1 Eidgenossische Technische Hochschule Zurich Ecole polytechnique federale de Zurich Politecnico federale di Zurigo Swiss Federal Institute of Technology Zurich Semantik von Programmiersprachen Theorie und Anwendungen (Informatik III, Wintersemester 03/04) Robert F. Stärk Institut für Theoretische Informatik ETH Zürich staerk Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 1

2 Inhalt Teil 1: Natürliche Semantik von Programmen Teil 2: ASM Semantik von Programmen Teil 3: Compilation auf virtuelle Maschine Teil 4: Denotationelle Semantik Teil 5: Hoare-Logik Teil 6: Dynamische Logik Teil 7: Bytecode Verification Teil 8: Proof-Carrying Code Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 2

3 Übersicht Denotationelle Semantik Aequvialenz Natürliche Semantik (big step) Hoare Logik Dynamische Logik Korrektheit der Axiome Aequivalenz ASM Semantik (small step) Compilation Virtuelle Maschine Proof carrying Code Bytecode Verification Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 3

4 Zusammenfassung Am Beispiel einer imperativen Programmiersprache mit einfachen Datentypen und rekursiven Prozeduren werden die elementaren Konzepte der Semantik von Programmiersprachen erklärt. Es wird gezeigt, inwiefern die operationelle mit der denotationellen Semantik übereinstimmt. Die denotationelle Semantik bildet die Grundlage für korrekte Axiome und Beweisregeln (sogenannte axiomatische Semantik oder Hoare Logik). Die operationelle Semantik wird benutzt für die beweisbar korrekte Compilation auf eine einfache virtuelle Maschine. Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 4

5 Folien mit Stern Folien, die rechts oben mit einem Stern markiert sind, enthalten Beweise von Sätzen und weiterführendes Material. Beim ersten Durcharbeiten können Stern-Folien übergangen werden. Der Inhalt der Stern-Folien ist nicht Prüfungsstoff. Beachte: Auch wenn die Beweise nicht als Prüfungsstoff gelten, sind sie trotzdem wichtig. Für das Verständnis der Semantik von Programmiersprachen sind sie genauso wichtig wie die Beispiele. Beweise sind eine Form der Kommunikation von abstrakten Konzepten und mathematischen Ideen unter Menschen. Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 5

6 Literatur Hanne Riis Nielson, Flemming Nielson Semantics with Applications: A Formal Introduction Wiley, Betrand Meyer Introduction to the Theory of Programming Lanuages Prentice Hall, 1990 Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 6

7 Weiterführende Literatur Glynn Winskel The Formal Semantics of Programming Languages: an Introduction The MIT Press, 1993 Carl A. Gunter Semantics of Programming Languages The MIT Press, 1992 John C. Mitchell Foundations of Programming Languages The MIT Press, 1996 Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 7

8 Weiterführende Literatur Krzysztof R. Apt, Ernst-Rüdiger Olderog Verification of Sequential and Concurrent Programs Springer-Verlag, 2nd ed., 1997 David Harel, Dexter Kozen, Jerzy Tiuryn Dynamic Logic The MIT Press, 2000 Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 8

9 Semantik von Programmiersprachen Was ist die Bedeutung eines Programms? Syntax Programmiersprache Statische Semantik Dynamische Semantik Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 9

10 Syntax Die Syntax wird durch eine Grammatik angegeben. Folge von Zeichen (Source File) lexikalische Analyse Folge von Tokens Parser abstrakter Syntaxbaum Die Grammatik definiert eine Relation zwischen Zeichenfolgen und abstrakten Syntaxbäumen. [Siehe Vorlesung Compilerbau.] Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 10

11 Semantik (statisch vs. dynamisch) Statische Semantik (Was muss zur Compilezeit überprüft werden?) Typregeln, Typüberprüfung statische Analyse (z.b. Definite Assignment) Auflösung von Namen Auflösung von Methoden (für überladene Methoden) Resultat: annotierter abstrakter Syntaxbaum Dynamische Semantik (Was geschieht zur Laufzeit?) Ausführung des Programms (program execution) Was definiert den Zustand eines Programms? Was ist der Effekt eines Programms auf den Zustand? Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 11

12 Dynamische Semantik Denotationelle Semantik (Programme = mathematische Objekte) Ein Programm wird betrachtet als (partielle) Funktion in einem mathematischen Raum. Gut für deklarative Sprachen (funktionale Programmierung). Zu kompliziert für objekt-orientierte Sprachen mit Vererbung, Exception Handling, Threads. Operationelle Semantik Varianten: Natürliche Semantik (Big-Step Semantics) SOS (Structural Operational Semantics) ASMs (Gurevich Abstract State Machines) Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 12

13 Anwendungen der Semantik Warum eine formale Spezifikation der Semantik einer Programmiersprache? nützlich für Implementation (korrekte Compilation, Platform-Unabhängigkeit) Grundlage für formale Methoden (erweiterte statische Analyse, Verifikation, Korrektheit von Axiomen und Beweisregeln) Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 13

14 Eine einfache imperative Programmiersprache While-Programme Nur zwei Typen: boolean, integer Boolesche Ausdrücke Arithmetische Ausdrücke Alle Variablen werden initialisiert Rekursive Prozeduren Werte- und Variablenparameter Keine Funktionen Keine Ausdrücke mit Seiteneffekten Reihenfolge der Auswertung der Argumente beliebig Keine globalen Variablen Kein zufälliges Verhalten wegen uninitialisierten Variablen Vermeidung von Alias-Problemen Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 14

15 Mitteilungszeichen (Metavariablen) Mitteilungszeichen: x, y, z für Variablen (Var) e, e 1, e für arithmetische Ausdrücke (Aexp) b, b 1, b für Boolesche Ausdrücke (Bexp) s, s, s 1, s für Anweisungen (Stm) p für Namen von Prozeduren Vektornotation: x = x 1, x 2,..., x m e = e 1, e 2,..., e n Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 15

16 Bedeutung der Anweisungen (informale Semantik) skip x := e Mache nichts (leere Anweisung). Weise x den Wert von e zu. s 1 ; s 2 Führe zuerst s 1 aus, danach s 2. if b then s 1 else s 2 end Falls b wahr ist, führe s 1 aus, sonst s 2. while b do s end var x := e in s end p( e; z) Solange b wahr ist, führe s aus. Erzeuge eine neue lokale Variable x mit dem Wert von e und führe s aus. Rufe die Prozedur p mit den Werten von e und den Variablen z auf. Bedingung: Die Variablen in z müssen paarweise verschieden sein. Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 16

17 Bedeutung der Ausdrücke (informale Semantik) Arithmetische Ausdrücke: x i Zugriff auf Variable Konstante (Literal) e 1 op e 2 Arithmetische Operation, op {+, -, *, /} Boolesche Ausdrücke: e 1 op e 2 Relation, op {=, #, <, <=, >, >=} not b Negation (nicht) b 1 and b 2 Konjunktion (und) b 1 or b 2 Disjunktion (oder) Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 17

18 Prozedurdeklaration: Formale Parameter: Prozedurdeklarationen procedure p( x; y) begin s end Die Variablen x sind Werteparameter (call-by-value) Die Variablen y sind Variablenparameter (call-by-name) Syntaktische Bedingungen: Die Variablen in x und y müssen paarweise verschieden sein. Jede freie Variable von s muss in x oder y vorkommen (keine globalen Variablen). Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 18

19 Grammatik der Programmiersprache EBNF (extended Backus-Naur Formalism) Terminalsymbol Nichtterminalsymbol Alternative Alternative {Wiederholung} [Optional] Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 19

20 Grammatik (Zeichen und Tokens) Zeichen: Letter = A.. Z a.. z. Digit = Tokens: Ident = Letter {Letter Digit}. Integer = Digit {Digit}. Var = Ident. Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 20

21 Grammatik (Anweisungen) Stm = skip Var := Aexp if Bexp then StmSeq else StmSeq end while Bexp do StmSeq end var Var := Aexp in StmSeq end Ident ( [AexpList] [ ; VarList] ). StmSeq = Stm { ; Stm}. AexpList = Aexp {, Aexp}. VarList = Var {, Var}. Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 21

22 Grammatik (Arithmetische Ausdrücke) Aexp = Term {AddOp Term}. Term = Factor {MulOp Factor}. Factor = Var Integer ( Aexp ). AddOp = + -. MulOp = * / div mod. Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 22

23 Grammatik (Boolesche Ausdrücke) Bexp = OrExp { or OrExp}. OrExp = PrimExp { and PrimExp}. PrimExp = not PrimExp ( Bexp ) Aexp RelOp Aexp. RelOp = = # < <= > >=. Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 23

24 Grammatik (Programme) Program = {Procedure}. Procedure = Head begin StmSeq end. Head = procedure Ident ( [VarList] [ ; VarList] ). Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 24

25 Bereiche der Variablen var x := e in }{{} Bereich von x end procedure p( x; y) begin }{{} Bereich von x und y end Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 25

26 Arithmetische Ausdrücke: Freie Variablen in Ausdrücken FV(x) = {x} FV(i) = FV(e 1 op e 2 ) = FV(e 1 ) FV(e 2 ) (i ein Integer) (op AddOp MulOp) Boolesche Ausdrücke: FV(e 1 op e 2 ) = FV(e 1 ) FV(e 2 ) (op RelOp) FV(not b) = FV(b) FV(b 1 and b 2 ) = FV(b 1 or b 2 ) = FV(b 1 ) FV(b 2 ) Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 26

27 Freie Variablen in Anweisungen FV(skip) = FV(x := e) = {x} FV(e) FV(s 1 ; s 2 ) = FV(s 1 ) FV(s 2 ) FV(if b then s 1 else s 1 end) = FV(b) FV(s 1 ) FV(s 2 ) FV(while b do s end) = FV(b) FV(s) FV(var x := e in s end) = FV(e) (FV(s) \ {x}) FV(p( e; z)) = FV( e) { z} Vektoren: Für e = e 1,..., e n ist FV( e) = FV(e 1 )... FV(e n ) Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 27

28 Syntaktische Abkürzungen if b then s end repeat s until b if b then s else skip end s; while not b do s end for x := e 1 to e 2 do s end x := e 1 ; var y := e 2 in while x <= y do s; x := x + 1 end end if b 1 then s 1 elsif b 2 then s 2 else s 3 end if b 1 then s 1 else if b 2 then s 2 else s 3 end end Bedingung für For-Schleife: x / FV(e 2 ), y / FV(s). Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 28

29 Liste der Folien Inhalt Übersicht Zusammenfassung Folien mit Stern Literatur Weiterführende Literatur Weiterführende Literatur Semantik von Programmiersprachen Syntax Semantik (statisch vs. dynamisch) Dynamische Semantik Anwendungen der Semantik Eine einfache imperative Programmiersprache Mitteilungszeichen (Metavariablen) Bedeutung der Anweisungen (informale Semantik) Bedeutung der Ausdrücke (informale Semantik) Prozedurdeklarationen Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 29

30 Grammatik der Programmiersprache Grammatik (Zeichen und Tokens) Grammatik (Anweisungen) Grammatik (Arithmetische Ausdrücke) Grammatik (Boolesche Ausdrücke) Grammatik (Programme) Bereiche der Variablen Freie Variablen in Ausdrücken Freie Variablen in Anweisungen Syntaktische Abkürzungen Copyright c 2004 Robert F. Stärk, Computer Science Department, ETH Zürich, Switzerland. 30