Universitetet i Linköping Institutionen för datavetenskap Anders Haraldsson

Transkript

1 1 2 Dagens föreläsning Modeller för programmeringsspråk Interpretator - att interpretera ett program - att beräkna ett program - Olika modeller programspråk Interpretator - kompilator program i S interpretator för S skrivet i P - Olika typer av språk Statiska och dynamiska programspråk - Syntax - semantik. Grammatik maskinkodsprogram datorns hårdvara -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 program i Kalkyl interpretatorför Kalkyl skrivet i Lisp - Kompilering i Lisp 3 4 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 Vi ser sålunda många olika modeller. program i Lisp Lisp-interpretator (eval) program i Ada Ada kompilator maskinkodsprogram Program i Ada Ada kompilator maskinkodsprogram datorns hårdvara program i Kalkyl Kalkyl översättare till Lisp program i Lisp Program i Java Java kompilator Java byte code Java byte code interpretator Numera kan Java byte code kompileras - Just in time kompilering

2 5 6 Ofta när vi säger att vi kompilerar, så menar vi att vi översätter ett program till maskinkod. Interpretering - kompilering Skall ett program (kommando) köras en gång kan interpretering vara snabbare. LOAD ADD a b Skall ett program köras många gånger går det fortare att köra ett kompilerat program än att interpretera. MULT STORE SUB c d e 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) JMPZE start EXCH Breg byt plats på värden Instruktionskoderna motsvaras av binära koder. a, b, c etc är namn för direkta adresser till minnet 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 8 Statiska - dynamiska programspråk Parsning av programkod. Ett statiskt programspråk är kompilerat. Deklarationer görs av alla variabler till en typ (stark typning) En funktion definieras att ta parametrar ev en typ och returnerar en typ (typsignaturen) Eller flera funktioner med samma namn men med olika typsignaturer (generiska funktioner). 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) Exempel på dynamiska språk: Lisp, Python, Ruby, Javascript Exempel på statiska språk: C, Java, Ada 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"

3 9 10 Lexikalisk analys Syntaxanalys - grammatik 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 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 <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 Resultatet kan var ett parsningsträd, som beskriver den abstrakta syntaxen, <program> begin <stmt_list> <stmt> end <var> := <expr> A <expr> * <expr> <var> ( <expr> ) B <expr> + <expr> <var> A <var> C

4 13 14 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) 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. 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 ) 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 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))

5 17 18 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 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 till det kompilerade programmet. För att exekvera den skapade koden, så applicerar vi den skapade funktion på en given värdetabell, dvs. Vi kan definiera en funktion exekvera. (defun exekvera (uttryck ) (funcall (kompilera-logik uttryck) )) (defun exekvera (uttryck ) (eval (list (kompilera-logik uttryck) (list quote )))) Översättning av logiska konstanter: sant översätts till (quote sant) falskt översätts till (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)) Översättning av de logiska konnektiven: (icke loguttr) -> (if (eq kod för loguutr (quote sant)) (kompilera-logik (icke sant)) => (lambda (värdetabell) (if (eq (quote sant) (quote sant)) (loguttr 1 och loguttr 2 ) -> (if (eq kod för loguttr 1 (quote sant)) kod för loguttr 2 )) (loguttr 1 eller loguttr 2 ) -> motsvarande

6 21 22 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) ((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...))) 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)) (defun skapa-och (lispkod-arg1 lispkod-arg2) (list if (list eq lispkod-arg1 (quote sant)) lispkod-arg2 )) Exempel på kompilering: (kompilera-logik (icke a)) ->(lambda (värdetabell) (if (eq (slå-upp-sanningsvärde (quote a) värdetabell)) (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))))) (eval ((lambda (värdetabell) (if (eq (slå-upp-sanningsvärde (quote a) värdetabell) (quote sant)) ((a. sant)))) -> ((lambda (värdetabell) (if (eq (slå-upp-sanningsvärde (quote a) värdetabell) (quote sant)) ((a. sant)))) => falskt

7 25 26 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. 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) 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 minilisp (*car (*quote (a b c))) = a (*car (*quote (a b c))) ()) (*car l) ((l. (a b c)))) (*cond ((*eq l nil) t) (t (*car l))) ((l. (x y z)))) 1. Dessa två begrepp tas upp i den sista föreläsningen

8 29 30 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))) )))))) (defun mini-eval (form env) ; uttryck x symboltabell -> uttryck ((constant? form) (evaluate-constant form)) ((variable? form) (lookup-value form env)) (itional? 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 ((primitive-function? fn) (primitive-apply fn args)) ((function-symbol? fn) (mini-apply (lookup-definition fn) args env)) ((lambda? fn) (body fn) (extend-env (bind (formal-params fn) args) env))) (t (error "u.d.f - undefined function ~s" fn)))) (defun evalargs (arg-list env) ; argumentlista x symboltabell -> argumentlista ((empty-args arg-list) '()) (t (cons (first-arg arg-list) env) (evalargs (rest-of-args arg-list) env))) )) (defun eval-conditional (clauses env) ; klausuler x symboltabell -> uttryck ((empty-clause-list? clauses) (error "no clause with true predicate")) ((true? (predicate (first-clause clauses)) env)) (expression (first-clause clauses)) env)) (t (eval-conditional (rest-of-clauses clauses) env)))) 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.

9 33 34 Kompilator Kompilerad kod av fakultetsfunktionen. 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. (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, %o : 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