Dagens föreläsning. Modeller för programmeringsspråk. - Olika modeller programspråk Interpretator - kompilator. - Syntax - semantik.

Transkript

1 1 Dagens föreläsning Modeller för programmeringsspråk - Olika modeller programspråk Interpretator - kompilator - Olika typer av språk Statiska och dynamiska programspråk - Syntax - semantik. Grammatik -Genomgång av logikspråket från laboration 2. Förberedelse inför laboration 5. - MiniLisp (kap 21) intepretator för pure Lisp funktionerna eval/apply - Kompilering i Lisp

2 2 Interpretator - att interpretera ett program - att beräkna ett program program i S interpretator för S skrivet i P utdata indata maskinkodsprogram datorns hårdvara utdata indata program i Kalkyl indata interpretator för Kalkyl skrivet i Lisp utdata

3 3 Kompilator - att kompilera ett program - att översätta ett program från ett språk till ett annat språk program i S kompilator för S som översätter till språket T program i språket T indata program i Ada Ada kompilator maskinkodsprogram indata program i Kalkyl Kalkyl översättare till Lisp indata program i Lisp

4 4 Vi ser sålunda många olika modeller. program i Lisp Lisp-interpretator (eval) utdata indata Program i Ada Ada kompilator maskinkodsprogram datorns hårdvara utdata indata Program i Java Java kompilator Java byte code Java byte code interpretator utdata indata Numera kan Java byte code kompileras - Just in time kompilering

5 5 Ofta när vi säger att vi kompilerar, så menar vi att vi översätter ett program till maskinkod. LOAD ADD MULT STORE SUB Areg Areg Areg Areg Areg a b c d e JMPZE Areg start EXCH Areg Breg byt plats på värden Instruktionskoderna motsvaras av binära koder. a, b, c etc är namn för direkta adresser till minnet

6 6 Interpretering - kompilering Skall ett program (kommando) köras en gång kan interpretering vara snabbare. Skall ett program köras många gånger går det fortare att köra ett kompilerat program än att interpretera. I Lisp så är program representerade som data i språkets strukturer, vilket medför att vi enkelt kan interpretera sådana strukturer och även under exekveringen skapa nya program eller ändra i existerande (jfr makro, som tas upp nästa föreläsning) Om ett språk är skrivet med en interpretator kan man se interpretatorn som en semantisk beskrivning av språket, genom att studera hur interpretatorn hanterar de olika konstruktionerna. Lisp beskrivs lätt i funktionerna eval och apply, som är interpretatorn för Lisp. Med en kompilator skulle man kunna studera den skapade objektkoden, men är vanligen mycket svårt. Common Lisp har även en kompilator, där man kompilerar en enskild funktion till maskinkod. Man kan blanda kompilerad och interpreterad kod.

7 7 Statiska - dynamiska programspråk Ett statiskt programspråk är kompilerat. Deklarationer görs av alla variabler till en typ (stark typning) var s : string s= abc s= 12 ger typfel Kompilatorn kontrollerar alla typer av uttryck och variabler stämmer överens. Ett dynamiskt programspråk tillåter oftast att en variabel har en pekare till ett dataobjekt, som i sin tur är typmärkt. Alltså kan en variabel bindas till värden av typer. Kontroller av att operationer får rätt typ görs under exekveringen. Ett dynamiskat språk är ofta interpreterat, men kan i många fall direkt kompileras till maskinkod/virtuell maskin. (Just in time kompilering)

8 8 Parsning av programkod. Program är en följd av tecken, som man skriver t ex med texteditorn emacs. Frågan är vilka teckenföljder bildar ett program, en sats, ett uttryck etc? x = y ( radie+sin 2 * pi) ; Konkret syntax - en följd av tecken Lexikalisk analys en följd av lexikaliska enheter Syntaktisk analys och parsning Abstrakt syntax - parseträd sedan kan vi använda parseträdet för beräkning eller som utgångspunkt för att generera maskinkod "kompilerad kod"

9 9 Lexikalisk analys int i = -3+x-sin(-1.5); består i Java av de lexikaliska enheterna (lexemes): int i = -3 + x - sin ( -1.5 ) ; Man har grundläggande enheter som kallas token: heltal, flyttal, sträng, identifierare, symbol etc Syntax bör utformas så att triviala fel ej kan får oväntade tolkningar: Exempel på gammalt känt fel: DO 10 I = 1.5 sats 10 sats

10 10 Syntaxanalys - grammatik En grammtik beskrivs i ett metaspråk med produktionsregler (rules, productions). Vi har terminal symboler och icke-terminala symboler. Terminal symboler skall återfinnas i programmet och markeras här med halvfet stil. <program> ::= 1 begin <stmt_list> end <stm_list> ::= <stmt> <stmt> ; <stmt_list> <stmt> ::= <var> := <expr> <var> ::= A B C <expr> ::= <expr> + <expr> <expr> * <expr> (<expr>) <var> Med en grammatik kan vi generera alla tänkbara program som finns. Med en grammatik kan vi avgöra om ett program uppfyller grammatiken. Vi önskar samtidigt få ett "parsningsträd (parse-tree). 1. Även -> användas för att skriva produktionsregler

11 11 <program> ::= begin <stmt_list> end <stm_list> ::= <stmt> <stmt> ; <stmt_list> <stmt> ::= <var> := <expr> <var> ::= A B C <expr> ::= <expr> + <expr> <expr> * <expr> (<expr>) <var> begin A := B * ( A + C ) end Att generera en mening (sentence) kallas "derivation" <program> => begin <stm_list> end => begin <stmt> end => begin <var> := <expr> end => begin A := <expr> end => begin A := <expr> * <expr> end => begin A := <var> * <expr> end => begin A := B * <expr> end => begin A := B * ( <expr> ) end => begin A := B * ( <expr> + <expr> ) end => begin A := B * ( <var> + <expr> ) end => begin A := B * ( A + <expr> ) end => begin A := B * ( A + <var> ) end => begin A := B * ( A + C) end

12 12 Resultatet kan var ett parsningsträd, som beskriver den abstrakta syntaxen, <program> begin <stmt_list> end <stmt> <var> := <expr> A <expr> * <expr> <var> ( <expr> ) B <expr> + <expr> <var> <var> A C

13 13 Till laboration 5 definierar vi språket KALKYL, med vilket vi kan göra aritmetiska beräkningar. Språket innehåller: (program sats 1 sats 2... stats n ) En sats kan vara en: tilldelning (variabel := uttryck) upprepning (medan villkorsuttryck sats 1 sats 2... stats n ) val (om villkorsuttryck sats sats) in- och utmatning (läs/skriv variabel) Ett uttryck kan vara: (uttryck 1 + uttryck 2 ) (uttryck 1 - uttryck 2 ) (uttryck 1 * uttryck 2 ) (uttryck 1 / uttryck 2 ) Ett villkorsuttryck kan vara: (uttryck 1 > uttryck 2 ) (uttryck 1 < uttryck 2 ) (uttryck 1 = uttryck 2 )

14 14 När vi använder Lisp, så sköter inläsningen (read-funktionen) uppgiften att göra den lexikaliska analysen och från parenteserna skapa en liststruktur, som motsvarar parse-trädet. Vi skall i laboration 5 implementera ett litet imperativt språk, Kalkyl.

15 15 Uppgift 5A: Skriv en interpretator för KALKYL, som vi kallar kalkylera. (kalkylera program) (kalkylera (program (a := 5) (skriv a))) A = 5 (kalkylera (program (läs n) (summa := 0) (medan (n > 0) (summa := (summa + n)) (n:= (n - 1))) (skriv summa))) Ge värde till N: 6 SUMMA = 21 Uppgift 5B: Skriv en kompilator för KALKYL som översätter programmet till Lisp-kod. Kalla den översätt. (översätt (program (skriv a))) => Lisp-kod, t ex en funktion som utför beräkningen

16 16 Som exempel utför vi dessa steg med LOGIKVÄRDE från laboration Först tittar vi på lösningen för LOGIKVÄRDE (ungefär som ni borde ha gjort!) 2. Sedan tittar vi på vilka ändringar vi behöver göra för att istället översätta=kompilera ett logikprogram till Lisp Definition av språket (konkret syntax): logiskt-uttryck = logiska sanningsvärden (sant och falskt) logisk variabel logiskt-uttryck logiskt-uttryck logiskt-uttryck logiskt-uttryck logiskt-uttryck Givet att a är sant och b är falskt vad är värdet av följande logiska uttryck? sant (a (b falskt))

17 17 En mer formell definition av ett programspråk kan vi t ex göra med att ge en grammatik för språket. Från grammatiken kan vi generera alla tänkbara program eller vi kan ta ett program och kontrollera om det uppfyller en grammatik (= parsing i samband med kompilatorer). Man använder ofta BNF-grammatik. Vi beskriver här den konkreta syntaxen (i parentesformat) för logiska uttryck (icke (a och (sant eller b))) <logik-uttryck> ::= <logik-konstant> <logik-variabel> ( icke <logik-uttryck>) ( <logik-uttryck> <logik-binär-operator> <logik-uttryck> ) <logik-konstant> -> sant falskt <logik-variabel> -> a b c... <logik-binär-operator> -> och eller

18 18 Kompilering av logiska uttryck till Lisp Ett logik-uttryck transformeras ( kompileras till ett motsvarande logiskt uttryck i Lisp. Vi kallar funktionen kompilera-logik. Av detta skapar vi en funktion, ett lambda-uttryck, som i sin tur tar en formell parameter i form av en värdetabell. Vi kallar denna formella parameter värdetabell. (lambda (värdetabell) logik-uttryck-i-lisp) Vi kan se argumentet värdetabell som indata till det kompilerade programmet. För att exekvera den skapade koden, så applicerar vi den skapade funktion på en given värdetabell, dvs indata. Vi kan definiera en funktion exekvera. (defun exekvera (uttryck indata) (funcall (kompilera-logik uttryck) indata)) (defun exekvera (uttryck indata) (eval (list (kompilera-logik uttryck) (list quote indata))))

19 19 Översättning av logiska konstanter: sant översätts till (quote sant) falskt översätts till (quote falskt) (kompilera-logik sant) => (lambda (värdetabell) (quote sant)) (värdetabell behövs ej för konstanter) Översättningen av en logisk variabel går till så att vi måste skapa ett uttryck som söker i värdetabellen. logiskt-variabel -> (slå-upp-sanningsvärde (quote logisk-variabel) värdetabell) (kompilera-logik a) => (lambda (värdetabell) (slå-upp-sanningsvärde (quote a) värdetabell))

20 20 Översättning av de logiska konnektiven: (icke loguttr) -> (if (eq kod för loguutr (quote sant)) (quote falskt) (quote sant))) (kompilera-logik (icke sant)) => (lambda (värdetabell) (if (eq (quote sant) (quote sant)) (quote falskt) (quote sant))) (loguttr 1 och loguttr 2 ) -> (if (eq kod för loguttr 1 (quote sant)) kod för loguttr 2 (quote falskt))) (loguttr 1 eller loguttr 2 ) -> motsvarande

21 21 Skapa funktionen med lambda och argument (defun kompilera-logik (uttryck) (list lambda (list värdetabell) (kompilera-uttryck uttryck))) Kompilera ett logiskt uttryck (defun kompilera-uttryck (uttryck) (cond ((konstant? uttryck) (skapa-konstant uttryck)) ((variabel? uttryck) (skapa-slå-upp-sanningsvärde uttryck)) ((icke-uttryck? uttryck) (skapa-icke (kompilera-uttryck (arg uttryck)))) ((och-uttryck? uttryck) (skapa-och (kompilera-uttryck (arg1 uttryck))) (kompilera-uttryck (arg2 uttryck)))) ((eller-uttryck?..).. på samma sätt...) (t... felmeddelande...)))

22 22 Skapa Lispkod för konstant (defun skapa-konstant (konstant) (list quote konstant)) Skapa Lispkod för variabel (defun skapa-slå-upp-sanningsvärde (variabel) (list slå-upp-sanningsvärde (list quote variabel) värdetabell)) Skapa Lispkod för icke- och och-uttryck. Obs att argumenten är ett färdigkompilerat uttryck, dvs Lispkod. (defun skapa-icke (lispkod-arg) (list if (list eq lispkod-arg (quote sant)) (quote falskt) (quote sant))) (defun skapa-och (lispkod-arg1 lispkod-arg2) (list if (list eq lispkod-arg1 (quote sant)) lispkod-arg2 (quote falskt)))

23 23 Exempel på kompilering: (kompilera-logik (icke a)) ->(lambda (värdetabell) (if (eq (slå-upp-sanningsvärde (quote a) värdetabell)) (quote sant)) (quote falskt) (quote sant))) Här följer vi både kompilering och exekvering: (exekvera (icke a) ((a. sant))) -> (eval (list (kompilera-logik (icke a)) (quote ((a. sant)))))

24 24 (eval ((lambda (värdetabell) (if (eq (slå-upp-sanningsvärde (quote a) värdetabell) (quote sant)) (quote falskt) (quote sant))) ((a. sant)))) -> ((lambda (värdetabell) (if (eq (slå-upp-sanningsvärde (quote a) värdetabell) (quote sant)) (quote falskt) (quote sant))) ((a. sant)))) => falskt

25 25 minilisp (kap 21) Här skissar vi en interpretator för Lisp (pure Lisp), dvs funktionen eval. Innehåller: - konstanter - variabler - villkorsuttryck - funktioner däremot ej: - lokala variabler - hopp - felhantering - makrofunktioner I kursbilbioteket finns fil med minilisp.

26 26 Interpretator för minilisp Interpretatorn beskriver språkets semantik (operationell semantik), dvs beskriver vad som händer då olika konstruktioner utförs. - när beräknas argumenten? - hur beräknas det villkorliga uttrycket? - hur hanteras variabler och data? - vad händer om en funktionsdefinition saknas? Interpretatorn följer den sk omgivningsmodellen. (Ej substitutionsmodellen vi använde för att visa rekursion)

27 27 Designbeslut statisk eller dynamisk 1 bindning? -> dynamisk bindning (lite enklare) hur organsiera symboltabellen? -> associationslista ((x. 3) (y. 5) (x. 2) (z. 4)) sökning efter första förekomsten var lagrar vi funktionsdefinitioner? -> i en global lista primitiva funktioner? -> kopplas till Common Lisp via en tabell syntax för minilisp? -> som Lisp, alla funktioner börjar * Hur hanteras special forms -> läggs in direkt i interpretatorn 1. Dessa två begrepp tas upp i den sista föreläsningen

28 28 minilisp (*car (*quote (a b c))) = a (mini-eval (*car (*quote (a b c))) ()) (mini-eval (*car l) ((l. (a b c)))) (mini-eval (*cond ((*eq l nil) t) (t (*car l))) ((l. (x y z))))

29 29 minilisp <-> Common Lisp (setq primitive-functions ( (*car. car) (*cdr. cdr) (*cons. cons) (*eq. eq) (*times. *)... )) (setq function-definitions ( (second. (*lambda (l) (*car (*cdr l)))) (fak. (*lambda (n) (*cond ((*eq n 0) 1) (t (*times n (fak (*sub1 n))) ))))))

30 30 (defun mini-eval (form env) ; uttryck x symboltabell -> uttryck (cond ((constant? form) (evaluate-constant form)) ((variable? form) (lookup-value form env)) ((conditional? form) (eval-conditional (clauses form) env)) (t (mini-apply (function-part form) (evalargs (args-part form) env) env)))) (defun mini-apply (fn args env) ; funktion x argumentlista x symboltabell -> uttryck (cond ((primitive-function? fn) (primitive-apply fn args)) ((function-symbol? fn) (mini-apply (lookup-definition fn) args env)) ((lambda? fn) (mini-eval (body fn) (extend-env (bind (formal-params fn) args) env))) (t (error "u.d.f - undefined function ~s" fn))))

31 31 (defun evalargs (arg-list env) ; argumentlista x symboltabell -> argumentlista (cond ((empty-args arg-list) '()) (t (cons (mini-eval (first-arg arg-list) env) (evalargs (rest-of-args arg-list) env))) )) (defun eval-conditional (clauses env) ; klausuler x symboltabell -> uttryck (cond ((empty-clause-list? clauses) (error "no clause with true predicate")) ((true? (mini-eval (predicate (first-clause clauses)) env)) (mini-eval (expression (first-clause clauses)) env)) (t (eval-conditional (rest-of-clauses clauses) env))))

32 32 Skapa en ny ram och bygg ut omgivningen (defun extend-env (new-bindings old-env) ; bindningar x symboltabell -> symboltabell (append new-bindings old-env)) (defun bind (formals values) ; parameterlista x argumentslista -> bindningar (mapcar # cons formals values)) För övriga primitiver se läroboken kapitel 21.

33 33 Kompilator Lisp kan hantera både funktioner som är kompilerade till maskinkod och funktioner som interpreterar liststruturformen. En enskild funktion kan kompileras med compile. En hel fil kan kompilera med compile-file (eller enklare via Allegro ACL-file). En fasl-fil skapas. En sådan fil kan laddas in med load. (Se laboration 4 - almanackan) Frågeställningar Kan kompilatorn antaga att de definitioner som finns tillgängliga vid kompileringstillfället även är giltiga vid exekveringstillfället. Detta medför att man vid anrop av en funktion ofta måste gå via symbolen för att hitta aktuell definition. Vi kan i språket skapa ny kod och ge till eval. Med makro och inline-deklarerade funktioner kan vi få ytterligare effektiviseringar.

34 34 Kompilerad kod av fakultetsfunktionen. (defun fak (n) (if (= n 0) 1 (* n (fak (- n 1))))) (disassemble fak) ;; disassembly of #<Function (:ANONYMOUS-LAMBDA #x4f21452> ;; formals: N ;; constant vector: 0:FAK ;; code start: #x4f21394: 0: 9de3bf98 save%o6, #x-68, %o6 4: 80a0e001 cmp%g3, #x1 8: 93d02010 tne%g0, #x10 12: taddcctv%g0, %g1, %g0 16: mov%i0, %o0 20: mov%g0, %o1 24: 810a0009 tsubcc%o0, %o1, %g0 28: 0e bvs60 32: nop 36: d bne,a88 40: a mov%i0, %l0 44: mov#x4, %o0 lb1: 48: mov#x1, %g3 lb2: 52: 81c7e008 jmp%i : 91ea0000 restore%o0, %g0, %o0 lb3: 60: c4013e83 ld[%g ], %g2; EXCL::=_2OP 64: 9fc1200b jmpl%g4 + 11, %o7 68: xor%g0, #x2, %g3 72: 80a10008 cmp%g4, %o0 76: 32bffff9 bne,a48 80: mov#x4, %o0

35 35 84: a mov%i0, %l0 lb4: 88: mov#x4, %o1 92: 990e0009 tsubcc%i0, %o1, %o4 96: 2e80000d bvs,a : c4013dd7 ld[%g ], %g2; EXCL::-_2OP lb5: 104: c ld[%i5 + 34], %g2; FAK 108: c mov%o4, %o0 112: 9fc1200b jmpl%g4 + 11, %o7 116: xor%g0, #x1, %g3 120: mov%o0, %o1 124: c4013da7 ld[%g ], %g2; EXCL::*_2OP 128: mov%l0, %o0 132: 9fc1200b jmpl%g4 + 11, %o7 136: xor%g0, #x2, %g3 140: 10bfffea ba52 144: nop lb6: 148: mov%i0, %o0 152: 9fc1200b jmpl%g4 + 11, %o7 156: xor%g0, #x2, %g3 160: 10bffff2 ba : mov%o0, %o4