1. Semantik och programteori 1 Tillämpning av denotationssemantik Semantiken hos ett större imperativt språk Semantik för kontextuella begränsningar Resonera om program

2. Semantik och programteori 2 Semantiska domäner l Specificera semantiska domäner lämpliga för språket vi vill definiera. Det behövs en domän för att modellera varje typ av värde i språket. Till dessa definieras hjälpfunktioner för att modellera operationer på dessa värden. I språket  behövs: m Primitiva typer: m Sammansatta typer m Första klassens värden m Andra värden m Omgivningen m Minne m Variabler

3. Semantik och programteori 3 Typer l Primitiva typer: m Truth-Value, Integers, Character l Sammansatta typer m Record-Value and Array-Value. l Första klassens värden m Value = disjunkt union av Truth-Value, Integer,Character, Record-Value och Array-Value. l Andra värden m Variable, Procedure, and Function

4. Semantik och programteori 4 Strukturer l Omgivningen m Bindable = disjunkt union av Value, Variable, Procedure, Function och Allocator l Minne (Store) m Storable = disjunkt union av Truth-Value, Integer, Character och Text. l Variabler m Record-Variable Array-Variable m Variable = disjunkt union av Location, Record-Variable och Array-Variable.

5. Semantik och programteori 5 Kontenta Ett bra val av domäner och hjälp funktioner tenderar till att göra de semantiska funktionerna relativt kortfattade och enkla att förstå.

6. Semantik och programteori 6 Semantiska funktions l För varje frasklass i programspråket väljer vi en domän för denotationen för fraser i den klassen och specificerar en semantisk funktion som mappar dessa fraser till deras denotation. m Kommandon  Environ  Store  Store. m Uttryck  Environ  Store  Value  Store. m Deklarationer  Environ  Store  Environ  Store.

7. Semantik och programteori 7 Uttryck som kommandoblock evaluate : Expression  (Environ  Store  Value  Store) evaluate [ begin C ; return E end ] env sto = letsto' = execute C env sto in evaluate E env sto' evaluate [E 1 + E 2 ] env sto = let(int 1, sto') = evaluate E 1 env sto in let(int 2, sto'') = evaluate E 2 env sto' in (sum (int 1, int 2 ), sto'') evaluate [N] env sto = (valuation N, sto) execute [I := E] env sto = let(val, sto') = evaluate E env sto in letvariable loc = find (env, I) in update (sto', loc, val )

8. Semantik och programteori 8 Denotation för uttryck, kommandon och deklarationer. FrasklassDomän för denotation Pure functional language: ExpressionEnviron  Value DeclarationEnviron  Environ Imperative language without side effects: ExpressionEnviron  Store  Value CommandEnviron  Store  Store DeclarationEnviron  Store  Environ  Store Imperative language with side effects: ExpressionEnviron  Store  Value  Store CommandEnviron  Store  Store DeclarationEnviron  Store  Environ  Store

9. Semantik och programteori 9 Abstraktioner l Abstraktionsdomäner i språk med statiska bindningar. Typ avDenotation för Abstraktionsdomän abstraktionabstraktionskropp Pure functional language: FunctionEnviron  ValueArgument*  Value Imperative language without side effects: FunctionEnviron  Store  ValueArgument*  Store  Value ProcedureEnviron  Store  StoreArgument*  Store  Store Imperative language with side effects: FunctionEnviron  Argument*  Store  Value  StoreStore  Value  Store ProcedureEnviron  Store  StoreArgument*  Store  Store

10. Semantik och programteori 10 Program och input–output run : Program  (Input  Output) program(input n :Integer,output p :Integer) ~ p := 1; while n > 0 do begin p := 2 * p; n := n - 1 end Program ::= program( input Identifier : Type-Denoter, output Identifier : Type-Denoter ) ~ Command

11. Semantik och programteori 11 Semantiska funktioner run : Program  (Value  Value) run [ program (input I 1 : T 1, output I 2 : T 2 ) ~ C] in-val = letsto = empty-store in let(sto 1, in-var) = allocate-variable T 1 empty-environ sto in let(sto 2, out-var) = allocate-variable T 2 empty-environ sto 1 in letsto 3 = update-variable (sto 2, in-var, in-val) in letenv = overlay (bind (I 1, variable in-var), bind (I 2, variable out-var)) in letsto 4 = execute C env sto 3 in fetch-variable (sto 4, out-var)

12. Semantik och programteori 12 Exempel C 1 = p := 1 C 2 = p := 2 * p C 3 = n := n - 1 C 4 = while n > 0 do begin C 2 ; C 3 end C 5 = C 1 ; C 4 run [ program(input n :Integer,output p :Integer) ~ C 5 ] v = letsto = empty-store in let(sto 1, in-var) = allocate-variable Integer empty-environ sto in let(sto 2, out-var) = allocate-variable Integer empty-environ sto 1 in letsto 3 = update-variable (sto 2, in-var, v) in lete 0 = overlay (bind ( n, variable in-var), bind ( p, variable out-var)) in letsto 4 = execute C 5 e 0 sto 3 in fetch-variable (sto 4, out-var)

13. Semantik och programteori 13 Exempel run [ program(input n :Integer,output p :Integer) ~ C 5 ] v = lets 0 = empty-store in let(s 1, in-var) = allocate-variable Integer empty-environ s 0 in let(s 2, out-var) = allocate-variable Integer empty-environ s 1 in lets 3 = update-variable (s 2, in-var, v) in lete 0 = overlay (bind ( n, variable in-var), bind ( p, variable out-var)) in lets 4 = execute C 5 e 0 s 3 in fetch-variable (s 4, out-var)

14. Semantik och programteori 14 Exempel run [ program(input n :Integer,output p :Integer) ~ C 5 ] v = lets 0 = empty-store in let(s 1, in-var) = let (sto,l 0 ) = allocate s 0 in (sto,primitiv-variable l 0 ) in let(s 2, out-var) = allocate-variable Integer empty-environ s 1 in lets 3 = update-variable (s 2, in-var, v) in lete 0 = overlay (bind ( n, variable in-var), bind ( p, variable out-var)) in lets 4 = execute C 5 e 0 s 3 in fetch-variable (s 4, out-var)

15. Semantik och programteori 15 Exempel run [ program(input n :Integer,output p :Integer) ~ C 5 ] v = lets 0 = empty-store in let(sto, l 0 ) = allocate s 0 in let(s 1, in-var) = (sto,primitiv-variable l 0 ) in let(s 2, out-var) = allocate-variable Integer empty-environ s 1 in lets 3 = update-variable (s 2, in-var, v) in lete 0 = overlay (bind ( n, variable in-var), bind ( p, variable out-var)) in lets 4 = execute C 5 e 0 s 3 in fetch-variable (s 4, out-var)

16. Semantik och programteori 16 Exempel run [ program(input n :Integer,output p :Integer) ~ C 5 ] v = lets 0 = empty-store in let(s 1, l 0 ) = allocate s 0 in letin-var = primitiv-variable l 0 in let(s 2, out-var) = allocate-variable Integer empty-environ s 1 in lets 3 = update-variable (s 2, in-var, v) in lete 0 = overlay (bind ( n, variable in-var), bind ( p, variable out-var)) in lets 4 = execute C 5 e 0 s 3 in fetch-variable (s 4, out-var)

17. Semantik och programteori 17 Exempel run [ program(input n :Integer,output p :Integer) ~ C 5 ] v = lets 0 = empty-store in let(s 1, l 0 ) = allocate s 0 in letin-var = primitiv-variable l 0 in let(s 2, l 1 ) = allocate s 1 in letout-var = primitiv-variable l 1 in lets 3 = update-variable (s 2, in-var, v) in lete 0 = overlay (bind ( n, variable in-var), bind ( p, variable out-var)) in lets 4 = execute C 5 e 0 s 3 in fetch-variable (sto 4, out-var)

18. Semantik och programteori 18 Exempel run [ program(input n :Integer,output p :Integer) ~ C 5 ] v = lets 0 = empty-store in let(s 1, l 0 ) = allocate s 0 in let(s 2, l 1 ) = allocate s 1 in letout-var = primitiv-variable l 1 in lets 3 = update-variable (s 2, primitiv-variable l 0, v) in lete 0 = overlay (bind ( n, variable (primitiv-variable l 0 )), bind ( p, variable out-var)) in lets 4 = execute C 5 e 0 s 3 in fetch-variable (s 4, out-var)

19. Semantik och programteori 19 Exempel run [ program(input n :Integer,output p :Integer) ~ C 5 ] v = lets 0 = empty-store in let(s 1, l 0 ) = allocate s 0 in let(s 2, l 1 ) = allocate s 1 in lets 3 = update-variable (s 2, primitiv-variable l 0, v) in lete 0 = overlay (bind ( n, variable (primitiv-variable l 0 )), bind ( p, variable (primitiv-variable l 1 ))) in lets 4 = execute C 5 e 0 s 3 in fetch-variable (s 4, primitiv-variable l 1 )

20. Semantik och programteori 20 Exempel run [ program(input n :Integer,output p :Integer) ~ C 5 ] v = lets 0 = empty-store in let(s 1, l 0 ) = allocate s 0 in let(s 2, l 1 ) = allocate s 1 in lets 3 = update (s 2, l 0, v) in lete 0 = overlay (bind ( n, variable (primitiv-variable l 0 )), bind ( p, variable (primitiv-variable l 1 ))) in lets 4 = execute C 5 e 0 s 3 in fetch-variable (s 4, primitiv-variable l 1 )

21. Semantik och programteori 21 Exempel run [ program(input n :Integer,output p :Integer) ~ C 5 ] v = let(s 1, l 0 ) = allocate empty-store in let(s 2, l 1 ) = allocate s 1 in lets 3 = update (s 2, l 0, v) in lete 0 = overlay (bind ( n, variable (primitiv-variable l 0 )), bind ( p, variable (primitiv-variable l 1 ))) in lets 4 = execute C 5 e 0 s 3 in fetch-variable (s 4, primitiv-variable l 1 )

22. Semantik och programteori 22 Exempel run [ program(input n :Integer,output p :Integer) ~ C 5 ] v = let(s 1, l 0 ) = allocate empty-store in let(s 2, l 1 ) = allocate s 1 in lets 3 = update (s 2, l 0, v) in lete 0 = overlay (bind ( n, variable (primitiv-variable l 0 )), bind ( p, variable (primitiv-variable l 1 ))) in lets 4 = execute C 5 e 0 sto 3 in fetch (s 4, l 1 )

23. Semantik och programteori 23 Exempel execute C 5 e 0 s 3 = execute [C 1 ; C 4 ] e 0 s 3

24. Semantik och programteori 24 Exempel execute C 5 e 0 s 3 = execute [ p := 1; C 4 ] e 0 s 3

25. Semantik och programteori 25 Exempel execute C 5 e 0 s 3 = execute C 4 e 0 (execute p := 1 e 0 s 3 )

26. Semantik och programteori 26 Exempel execute C 5 e 0 s 3 = execute C 4 e 0 (let val = evaluate 1 e 0 s 3 in let variable var = identify p e 0 in update-variable(s 3, var,val) )

27. Semantik och programteori 27 Exempel execute C 5 e 0 s 3 = execute C 4 e 0 (let val = integer (valuation 1 ) in let variable var = identify p e 0 in update-variable(s 3, var,val) )

28. Semantik och programteori 28 Exempel execute C 5 e 0 s 3 = execute C 4 e 0 (let val = integer 1 in let variable var = identify p e 0 in update-variable(s 3, var,val) )

29. Semantik och programteori 29 Exempel execute C 5 e 0 s 3 = execute C 4 e 0 (let variable var = identify p e 0 in update-variable(s 3, var, integer 1) ) identify p e 0 = find (e 0, p ) = find (overlay (bind ( n, variable (primitiv-variable l 0 )), bind ( p, variable (primitiv-variable l 1 ))), p ) = find (bind ( p, variable (primitiv-variable l 1 )), p ) = variable (primitiv-variable l 1 ))

30. Semantik och programteori 30 Exempel execute C 5 e 0 s 3 = execute C 4 e 0 (let variable var = variable (primitiv-variable l 1 ) in update-variable(s 3, var, integer 1) )

31. Semantik och programteori 31 Exempel execute C 5 e 0 s 3 = execute C 4 e 0 (update-variable(s 3, primitiv-variable l 1, integer 1))

32. Semantik och programteori 32 Exempel execute C 5 e 0 s 3 = execute C 4 e 0 (update(s 3, l 1, integer 1))

33. Semantik och programteori 33 Exempel execute C 5 e 0 s 3 = let s 31 = update(s 3, l 1, integer 1) in execute C 4 e 0 s 31

34. Semantik och programteori 34 Exempel execute C 5 e 0 s 3 = let s 31 = update(s 3, l 1, integer 1) in execute [ while n > 0 do begin C 2 ; C 3 end ] e 0 s 31

35. Semantik och programteori 35 Exempel execute C 5 e 0 s 3 = let s 31 = update(s 3, l 1, integer 1) in let execute-while env sto = if evaluate [ n > 0 ] env sto = truth-value true then execute-while env (execute [C 2 ; C 3 ] env sto) else sto in execute-while e 0 s 31

36. Semantik och programteori 36 Exempel execute C 5 e 0 s 3 = let s 31 = update(s 3, l 1, integer 1) in let execute-while sto = if evaluate [ n > 0 ] e 0 sto = truth-value true then execute-while (execute [C 2 ; C 3 ] e 0 sto) else sto in execute-while s 31

37. Semantik och programteori 37 Exempel execute C 5 e 0 s 3 = let s 31 = update(s 3, l 1, integer 1) in let execute-while sto = if (let integer int 1 = evaluate n e 0 sto in let integer int 2 = evaluate 0 e 0 sto in truth-value (greater(int 1, int 2 )) = truth-value true) then execute-while (execute [C 2 ; C 3 ] e 0 sto) else sto in execute-while s 31

38. Semantik och programteori 38 Exempel execute C 5 e 0 s 3 = let s 31 = update(s 3, l 1, integer 1) in let execute-while sto = if (let integer int 1 = coerce(sto,identify n e 0 ) in let integer int 2 = evaluate 0 e 0 sto in truth-value (greater(int 1, int 2 )) = truth-value true) then execute-while (execute [C 2 ; C 3 ] e 0 sto) else sto in execute-while s 31

39. Semantik och programteori 39 Exempel execute C 5 e 0 s 3 = let s 31 = update(s 3, l 1, integer 1) in let execute-while sto = if (let integer int 1 = coerce(sto,find(e 0, n )) in let integer int 2 = evaluate 0 e 0 sto in truth-value (greater(int 1, int 2 )) = truth-value true) then execute-while (execute [C 2 ; C 3 ] e 0 sto) else sto in execute-while s 31

40. Semantik och programteori 40 Exempel execute C 5 e 0 s 3 = let s 31 = update(s 3, l 1, integer 1) in let execute-while sto = if (let integer int 1 = coerce(sto, variable (primitiv-variable l 0 )) in let integer int 2 = evaluate 0 e 0 sto in truth-value (greater(int 1, int 2 )) = truth-value true) then execute-while (execute [C 2 ; C 3 ] e 0 sto) else sto in execute-while s 31

41. Semantik och programteori 41 Exempel execute C 5 e 0 s 3 = let s 31 = update(s 3, l 1, integer 1) in let execute-while sto = if (let integer int 1 = fetch-variable(sto,primitiv-variable l 0 ) in let integer int 2 = evaluate 0 e 0 sto in truth-value (greater(int 1, int 2 )) = truth-value true) then execute-while (execute [C 2 ; C 3 ] e 0 sto) else sto in execute-while s 31

42. Semantik och programteori 42 Exempel execute C 5 e 0 s 3 = let s 31 = update(s 3, l 1, integer 1) in let execute-while sto = if (let integer int 1 = fetch (sto,l 0 ) in let integer int 2 = evaluate 0 e 0 sto in truth-value (greater(int 1, int 2 )) = truth-value true) then execute-while (execute [C 2 ; C 3 ] e 0 sto) else sto in execute-while s 31

43. Semantik och programteori 43 Exempel execute C 5 e 0 s 3 = let s 31 = update(s 3, l 1,integer 1) in let execute-while sto = if (let integer int 1 = fetch (sto,l 0 ) in let integer int 2 = integer 0 in truth-value (greater(int 1, int 2 )) = truth-value true) then execute-while (execute [C 2 ; C 3 ] e 0 sto) else sto in execute-while s 31

44. Semantik och programteori 44 Exempel execute C 5 e 0 s 3 = let s 31 = update(s 3, l 1,integer 1) in let execute-while sto = if (let integer int 1 = fetch (sto,l 0 ) in truth-value (greater(int 1, 0)) = truth-value true) then execute-while (execute [C 2 ; C 3 ] e 0 sto) else sto in execute-while s 31

45. Semantik och programteori 45 Exempel execute C 5 e 0 s 3 = let s 31 = update(s 3, l 1,integer 1) in let execute-while sto = if (let integer int 1 = fetch (sto,l 0 ) in greater(int 1, 0) = true) then execute-while (execute [C 2 ; C 3 ] e 0 sto) else sto in execute-while s 31

46. Semantik och programteori 46 Exempel execute C 5 e 0 s 3 = let s 31 = update(s 3, l 1,integer 1) in let execute-while sto = if (let integer int 1 = fetch (sto,l 0 ) in greater(int 1, 0)) then execute-while (execute [C 2 ; C 3 ] e 0 sto) else sto in execute-while s 31

47. Semantik och programteori 47 Exempel execute C 5 e 0 s 3 = let s 31 = update(s 3, l 1,integer 1) in let execute-while sto = let integer int 1 = fetch (sto,l 0 ) in if greater(int 1, 0) then execute-while (execute [C 2 ; C 3 ] e 0 sto) else sto in execute-while s 31

48. Semantik och programteori 48 Exempel execute C 5 e 0 s 3 = let s 31 = update(s 3, l 1,integer 1) in let execute-while sto = let integer int 1 = fetch (sto,l 0 ) in if greater(int 1, 0) then execute-while (execute C 3 e 0 (execute C 2 e 0 sto)) else sto in execute-while s 31

49. Semantik och programteori 49 Exempel execute C 5 e 0 s 3 = let s 31 = update(s 3, l 1,integer 1) in let execute-while sto = let integer int 1 = fetch (sto,l 0 ) in if greater(int 1, 0) then execute-while (execute C 3 e 0 (execute [ p := 2 * p ] e 0 sto)) else sto in execute-while s 31

50. Semantik och programteori 50 Exempel execute C 5 e 0 s 3 = let s 31 = update(s 3, l 1,integer 1) in let execute-while sto = let integer int 1 = fetch (sto,l 0 ) in if greater(int 1, 0) then execute-while (execute C 3 e 0 ( let val = evaluate [ 2 * p ] e 0 sto in let variable var = identify p e 0 in update-variable (sto,var,val))) else sto in execute-while s 31

51. Semantik och programteori 51 Exempel execute C 5 e 0 s 3 = let s 31 = update(s 3, l 1,integer 1) in let execute-while sto = let integer int 1 = fetch (sto,l 0 ) in if greater(int 1, 0) then execute-while (execute C 3 e 0 ( let integer int 2 = fetch (sto, l 1 ) in update (sto, l 1,integer(times(2,int 2 ))))) else sto in execute-while s 31

52. Semantik och programteori 52 Exempel execute C 5 e 0 s 3 = let s 31 = update(s 3, l 1,integer 1) in let execute-while sto = let integer int 1 = fetch (sto,l 0 ) in if greater(int 1, 0) then let s 32 =let integer int 2 = fetch (sto, l 1 ) in update (sto, l 1,integer(times(2,int 2 ))) in execute-while (execute C 3 e 0 s 32 ) else sto in execute-while s 31

53. Semantik och programteori 53 Exempel execute C 5 e 0 s 3 = let s 31 = update(s 3, l 1,integer 1) in let execute-while sto = let integer int 1 = fetch (sto,l 0 ) in if (greater(int 1, 0) = true) thenlet integer int 2 = fetch (sto, l 1 ) in let s 32 =update (sto, l 1, integer(times(2,int 2 ))) in execute-while (execute C 3 e 0 s 32 ) else sto in execute-while s 31

54. Semantik och programteori 54 Exempel execute C 5 e 0 s 3 = let s 31 = update(s 3, l 1,integer 1) in let execute-while sto = let integer int 1 = fetch (sto,l 0 ) in if greater(int 1, 0) thenlet integer int 2 = fetch (sto, l 1 ) in let s 32 =update (sto, l 1, integer(times(2,int 2 ))) in execute-while (execute [ n := n - 1 ] e 0 s 32 ) else sto in execute-while s 31

55. Semantik och programteori 55 Exempel execute C 5 e 0 s 3 = let s 31 = update(s 3, l 1,integer 1) in let execute-while sto = let integer int 1 = fetch (sto,l 0 ) in if greater(int 1, 0) thenlet integer int 2 = fetch (sto, l 1 ) in let s 32 =update (sto, l 1, integer(times(2,int 2 ))) in let integer int 3 = fetch (s 32, l 0 ) in let s 33 =update (s 32, l 0, integer(minus(int 1,1))) in execute-while s 33 else sto in execute-while s 31

56. Semantik och programteori 56 Exempel run [ program(input n :Integer,output p :Integer) ~ C 5 ] v = let (s 1, l 0 ) = allocate empty-store in let (s 2, l 1 ) = allocate s 1 in lets 3 = update (s 2, l 0, v) in lete 0 = overlay (bind ( n, variable (primitiv-variable l 0 )), bind ( p, variable (primitiv-variable l 1 ))) in lets 4 = execute C 5 e 0 s 3 in fetch (s 4, l 1 )

57. Semantik och programteori 57 Exempel run [ program(input n :Integer,output p :Integer) ~ C 5 ] v = let(s 1, l 0 ) = allocate empty-store in let (s 2, l 1 ) = allocate s 1 in lets 3 = update (s 2, l 0, v) in lete 0 = overlay (bind ( n, variable (primitiv-variable l 0 )), bind ( p, variable (primitiv-variable l 1 ))) in letsto 4 =let s 31 = update(s 3, l 1,integer 1) in let execute-while sto = let integer int 1 = fetch (sto,l 0 ) in if greater(int 1, 0) thenlet integer int 2 = fetch (sto, l 1 ) in let s 32 = update (sto, l 1, integer(times(2,int 2 )))) in let integer int 3 = fetch (s 32, l 0 ) in let s 33 = update (s 32, l 0, integer(minus(int 1,1))) in execute-while s 33 else sto in execute-while s 31 in fetch(sto 4, l 1 )

58. Semantik och programteori 58 Exempel run [ program(input n :Integer,output p :Integer) ~ C 5 ] v = let(s 1, l 0 ) = allocate empty-store in let (s 2, l 1 ) = allocate s 1 in lets 3 = update (s 2, l 0, v) in lete 0 = overlay (bind ( n, variable (primitiv-variable l 0 )), bind ( p, variable (primitiv-variable l 1 ))) in let s 31 = update(s 3, l 1,integer 1) in let execute-while sto = let integer int 1 = fetch (sto,l 0 ) in if greater(int 1, 0) thenlet integer int 2 = fetch (sto, l 1 ) in let s 32 = update (sto, l 1, integer(times(2,int 2 ))) in let integer int 3 = fetch (s 32, l 0 ) in let s 33 = update (s 32, l 0, integer(minus(int 1,1))) in execute-while s 33 else sto in fetch(execute-while s 31, l 1 )

59. Semantik och programteori 59 Klart run [ program(input n :Integer,output p :Integer) ~ C 5 ] v = let(s 1, l 0 ) = allocate empty-store in let (s 2, l 1 ) = allocate s 1 in lets 3 = update (s 2, l 0, v) in lets 31 = update(s 3, l 1,integer 1) in letexecute-while sto = let integer int 1 = fetch (sto,l 0 ) in if greater(int 1,0) thenlet integer int 2 = fetch (sto, l 1 ) in let s 32 = update (sto, l 1, integer(times(2,int 2 ))) in let integer int 3 = fetch (s 32, l 0 ) in let s 33 = update (s 32, l 0, integer(minus(int 1,1))) in execute-while s 33 else sto in fetch(execute-while s 31, l 1 )

60. Semantik och programteori 60 Utan typtaggar run [ program(input n :Integer,output p :Integer) ~ C 5 ] v = let(s 1, l 0 ) = allocate empty-store in let (s 2, l 1 ) = allocate s 1 in lets 3 = update (s 2, l 0, v) in lets 31 = update(s 3, l 1,1) in letexecute-while sto = let int 1 = fetch (sto,l 0 ) in if greater(int 1,0) thenlet int 2 = fetch (sto, l 1 ) in let s 32 = update (sto, l 1, times(2,int 2 )) in let integer int 3 = fetch (s 32, l 0 ) in let s 33 = update (s 32, l 0,minus(int 1,1)) in execute-while s 33 else sto in fetch(execute-while s 31, l 1 )

61. Semantik och programteori 61 Än mer förenklat run [ program(input n :Integer,output p :Integer) ~ C 5 ] v = let(s 1, l 0 ) =allocate empty-store in let(s 2, l 1 ) =allocate s 1 in lets 3 =update (s 2, l 0, v) in lets 31 =update(s 3, l 1,1) in letexecute-while sto = if greater(fetch (sto,l 0 ),0) thenlet s 32 =update (sto, l 1,times(2, fetch (sto, l 1 ))) in let s 33 =update (s 32, l 0,minus(fetch (s 32, l 0 ),1)) in execute-while s 33 else sto in fetch(execute-while s 31, l 1 )

62. Semantik och programteori 62 Kontextuella restriktioner l Av all meningar som genereras av programspråkets grammatik är endast en del välformade program. De kontextuella restriktionerna är regler som avgör om ett givet program är välformat eller ej. De avgör också om enstaka programfraser är välformade eller ej.  let const m ~ 10 in ‚ let var p : bool in  p := (m > 0) l Omgivningar:  {} ‚ {m  integer-type}  {m  integer-type, p  var truth-type}.

63. Semantik och programteori 63 Begränsningar Typ omgivningDynamisk omgivning  { }{ } ‚ {m  integer-type}{m   10}  {m  integer-type,{m   10, p  var truth-type}p   en variabel innehållande ett truth-value}

64. Semantik och programteori 64 Denotationssemantik l För varje programspråk definierar vi en domän Type, vars element representerar typer i språket. Låt domänen för typ omgivning vara Type-Environ, med följande hjälp funktioner: empty-environ : Type-Environ bind: Identifier  Type  Type-Environ overlay: Type-Environ  Type-Environ  Type-Environ find: Type-Environ  Identifier  Type Type-Environ = Identifier  (bound Type + unbound)

65. Semantik och programteori 65 För språket IMP: l Domän Type = truth-type + integer-type + var Type + error-type equivalent : Type  Type  Truth-Value equivalent (typ1, typ2) = (typ1 = typ2)

66. Semantik och programteori 66 Semantiska funktioner constrain: Command  (Type-Environ  Truth-Value) typify: Expression  (Type-Environ  Value-Type) declare: Declaration  (Type-Environ  Truth-Value  Type-Environ) type-denoted-by: Type-Denoter  Value-Type

67. Semantik och programteori 67 Constrain constrain : Command  (Type-Environ  Truth-Value) constrain [ skip ] typenv = true constrain [I := E] typenv = lettyp = find (typenv, I) in lettyp' = typify E typenv in equivalent (typ, var typ') constrain [ let D in C] typenv = let(ok, typenv') = declare D typenv in if ok then constrain C (overlay (typenv', typenv)) else false

68. Semantik och programteori 68 Constrain Fortsättning constrain [C 1 ; C 2 ] typenv = constrain C 1 typenv  constrain C 2 typenv constrain [ if E then C 1 else C 2 ] typenv = equivalent (typify E typenv, truth-type)  constrain C 1 typenv  constrain C 2 typenv constrain [ while E do C] typenv = equivalent (typify E typenv, truth-type)  constrain C typenv

69. Semantik och programteori 69 Typify typify : Expression  (Type-Environ  Value-Type) typify [N] typenv = integer-type typify [ false ] typenv = truth-type typify [I] typenv = letvalue-type-of (truth-type) = truth-type value-type-of (integer-type) = integer-type value-type-of (var typ) = typ value-type-of (error-type) = error-type in value-type-of (find (typenv, I)) typify [E 1 + E 2 ] typenv = if equivalent (typify E 1 typenv, integer-type)  equivalent (typify E 2 typenv, integer-type) then integer-type else error-type

70. Semantik och programteori 70 Declare declare : Declaration  (Type-Environ  Truth-Value  Type-Environ) declare [ const I ~ E] typenv = lettyp = typify E typenv in if equivalent (typ, error-type) then (false, empty-environ) else (true, bind (I, typ)) declare [ var I : T] typenv = lettyp = type-denoted-by T in (true, bind (I, var typ))

71. Semantik och programteori 71 Type-denoted-by type-denoted-by : Type-Denoter  Value-Type type-denoted-by [ bool ]= truth-type type-denoted-by [ int ]= integer-type

72. Semantik och programteori 72 Resonera om program l Genom att ge en rent matematisk mening åt varje program, låter oss denotationssemantiken att etablera semantiska egenskaper hos program med hjälp av matematiskt resonemang. l Framförallt behöver vi ibland bevisa att två kommandon är semantiskt ekvivalenta. I så fall kan vi ersätta det ena kommandot med det andra i programtransformationer. Vi bevisar ekvivalens genom att visa att deras denotation är lika.

73. Semantik och programteori 73 Visa: C ; skip  C execute [C ; skip ] e s = execute [ skip ] e (execute C e s) = execute C e s Därför är execute [C ; skip ] = execute C.

74. Semantik och programteori 74 Bevis av While while E do C  if E then begin C ; while E do C end else skip execute [ begin C end ] = execute C execute[ if E then begin C ; while E do C end else skip ] e s =if evaluate E e s = truth-value true then execute [ begin C ; while E do C end ] e s else execute [ skip ] e s =if evaluate E e s = truth-value true then execute [C ; while E do C] e s else s =if evaluate E e s = truth-value true then execute [ while E do C] e (execute C e s) else s =execute [ while E do C] e s