T3 in het wild While Juni Tom de Valk Tom Evers Sjors Meekels

Transcriptie

1 T3 in het wild While Juni 2004 Tom de Valk Tom Evers Sjors Meekels

2 INHOUDSOPGAVE Inleiding WHILE OO Afbakening Uitbreidingen Syntax Semantiek States en environment State Env p Env do Heap Env this Uitbreiding van de Semantiek van A & B State transitie Update object declaratie State transitie bij object initialisatie NS Semantiek Voorbeeld Inheritance Syntax Semantiek Env do uitbreiden Update functie Object Initialisatie Semantiekregels Voorbeeld Keywords Public & Private Syntax uitbreiding Semantiek Semantiekregels Geneste objecten Syntax States en environment Semantiek Conclusie T3 in het Wild While 1

3 Inleiding De bedoeling van dit werkstuk is dat we semantische technieken kunnen ontwikkelen en toepassen in het wild. Het onderwerp dat we gekozen hebben, is het uitbreiden van de taal While met een aantal typische Object Oriented (OO) onderwerpen. Deze nieuwe taal hebben we de naam While OO gegeven. While OO is geen OO-taal in zuivere zin, maar meer de taal While met OO aspecten. We leggen de syntax en ns-semantiek van objecten en klassen vast. In de syntax wordt het declareren van objecten al sterk aan banden gelegd, dit is namelijk alleen mogelijk aan het begin van het programma. Bovendien is het niet toegestaan klassen in klassen te declareren, om het niet meteen te moeilijk te maken. Vervolgens gaan we de ns-semantiek vastleggen. Dit houdt onder andere in dat de state wordt uitgebreid, er update functies worden toegevoegd en de ns-semantiek regels worden aangepast. Nadat we deze implementatie van While OO hebben gerealiseerd, wordt er ingegaan op een ander typisch OO onderwerp, namelijk inheritance. Deze uitbreiding van While OO wordt in een apart hoofdstuk gedaan, omdat het anders te onoverzichtelijk wordt. Andere typische OO onderwerpen zoals klassen declareren in klassen (nesting van klassen) en de keywords public en private zullen we minder uitgebreid behandelen. Dit houdt in dat we de syntax en ns-semantiek niet exact zullen vastleggen, maar wel globaal bespreken hoe deze onderwerpen in While OO verwerkt kunnen worden. Concreet gezegd gaan we dus onderzoek doen naar de uitbreiding van de syntax en semantiek van de taal While met OO aspecten, te weten object declaraties en object instantiaties en we beschrijve n de benodigdheden voor inheritance en geneste klassen. T3 in het Wild While 2

4 1. WHILE OO 1.1 Afbakening Het uitbreiden van While kan op meerdere wijzen geïmplementeerd worden. Om het overzichtelijk te houden tijdens de beginfase, hebben wij ervoor gekozen om het declareren van objecten alleen toe te staan in het begin van het programma. Een ander belangrijk gevolg van deze keuze is de onmogelijkheid om objecten in objecten te declareren. Beide gevolgen zijn een inbreuk op de zuivere OO gedachte, echter er blijft voldoende expressieve kracht over om van een OO taal te spreken. Andere mogelijke uitgangspunten voor implementaties zouden kunnen zijn: Alles in objecten te zetten, dit impliceert dat alle variabelen en procedures dus ook in een object zitten. Verder houdt dit in dat elke programma dus een object is en er ergens een start (soort main () functie ) aanwezig dient te zijn. We hebben ervoor gekozen om hier niet voor te kiezen maar de taal While OO (backwards)compatible te maken met While. 1.2 Uitbreidingen Op de eerste plaats hebben wij de aritmetische expressie uitgebreid met de velden van een object. Zodoende kan een veld gebruikt worden als zijnde een normale aritmetische expressie. Dit is nodig om bijvoorbeeld de waarde van een veld aan een variabele toe te kennen of om de waarde van een veld aan te passen. Omdat wij een onderscheid maken tussen gedeclareerde en geïnstantieerde objecten is het ook nodig om dit verschil te kunnen maken bij het gebruik van velden. Hiervoor hebben wij de object.veldnaam en this.veldnaam geïntroduceerd. Deze gebruiken we respectievelijk bij een geïnstantieerd en een gedeclareerd object. In de syntax worden ze beschreven met o.v en this.v. De this.veldnaam constructie is een speciaal geval van object.veldnaam en heeft alleen betekenis binnen de declaratie van een object. (in D o ). Hierdoor is het mogelijk om naar procedures en velden te verwijzen in het huidige object voordat deze daadwerkelijk geïnstantieerd is. Het afdwingen van de declaratie van objecten aan het begin van een programma hebben wij geïmplementeerd met een apart statement R die vooraf gaat aan de originele S. In deze R kunnen vervolgens objecten worden gedeclareerd, dit is echter niet noodzakelijk, het laatste onderdeel van R is de normale S. Hierdoor zijn alle mogelijkheden van traditioneel While direct overgenomen. Objecten worden op een gelijke wijze gedeclareerd als bijvoorbeeld procedures. Het is een eindige rij met object declaraties, zie de definitie van D o. T3 in het Wild While 3

5 2. Syntax De syntax met de besproken uitbreidingen komt er nu zo uit te zien: a::= R::= n x a 1 + a 2 a 1 * a 2 a 1 a 2 o.v this.v begin Dv Dp Do Dd S end S::= x:= a skip S1 ; S2 if b then S1 else S2 while b do S begin D v D p D d S end call p call o.p call this.p o.v := a this.v := a Dv ::= var x := a ; Dv e D p ::= proc p is S ; D p e D o ::= class O is D v D p ; D o e D d ::= object o : = new O ; D d e De O is een metavariabele die de type van objecten beschrijft. (O type ) o is een metavariabele die de namen van objecten beschrijft. (O name ) D o is een metavariabele die de declaratie van objecten beschrijft. De v in o.v en this.v is een metavariabele die de namen van velden van objecten beschrijft. D d is eveneens een metavariabele die de instantiatie van objecten beschrijft binnen een Begin End block. De aparte metavariabele voor instanties is noodzakelijk om de instanties te kunnen opruimen bij het verlaten van de scope. (zie definities van Block) T3 in het Wild While 4

6 3. Semantiek Het is nuttig eerst een functie te definiëren die uit een tupel (of een rij) een zeker element haalt. In de volgende paragrafen zal blijken dat deze functie bestaansrecht heeft. Projectiefunctie: p i (x 0,x 1..x n ) = x i 3.1 States en environment Zoals gezegd en gezien is de syntax aangepast, dit heeft natuurlijk ook invloed op de benadering van state en environment. Wij maken onderscheid tussen een vijftal onderdelen. De normale State, met hierin de globale variabelen De normale Env p, met hierin de globale procedures Een speciaal environment env do, hierin worden alle gedeclareerde objecten opgeslagen, inclusief de procedures en velden. Een heap waarin de geïnstantieerde objecten worden opgeslagen. Van deze objecten hebben wij alleen de naam nodig en de velden. Een speciaal environment (veld) envthis, waarin we de objectnaam opslaan waar we op dat moment in bezig zijn. We zullen de bovenstaande aanpassingen stuk voor stuk bespreken en nader toelichten met voorbeelden State De standaard State zullen we gewoon blijven gebruiken. Deze kan zowel in R als in S uitgebreid worden met nieuwe variabelen. Semantisch is er geen verschil tussen gebruik in R en S, echter bij gebruik in R kunnen de variabelen ook al gebruikt worden in de object declaraties in R. Zo kunnen objecten ook gebruik maken van globale variabelen. Formeel gezien geldt nog steeds de volgende formule met een schets van het geheugen gebruik: State : V name Z X 3 Y De totale functie State levert dus altijd een waarde uit het bereik van Z op. T3 in het Wild While 5

7 3.1.2 Env p Ook de Envp zal niet worden gewijzigd, ook hier geldt dat hij in zowel R als in S kan worden uitgebreid. Hierin worden alle procedures opgeslagen die niet voorkomen in een object (dit wordt later behandeld). Formeel levert dit wederom de volgende functie en schets op: Env p : P name Stm P P body Q Q body.... De partiële functie env p levert niet altijd een resultaat op, omdat deze een Statement op moet leveren. Indien de P name niet voorkomt in env p is de kans groot bij een concrete implementatie dat er naar een waarde wordt gewezen die niet is te interpreteren als zijnde een geldig Statement Env do We houden een extra (static) environment bij waarin we alle gedeclareerde objecten opslaan, Env do (Declared Objectes). Deze kunnen alleen in R worden gedeclareerd. Na de declaratie van de objecten zal dit environment niet meer veranderen. Hierin worden de initialisatie waarden voor de velden en body s van de procedures opgeslagen. Formeel gezien: Env do : O type (State x Env p ) O1 X 3 P body Y 5 q body O2 X 1 P body Voorbeeld 3.1: class O n is var x:= 3; var y:= this.x + 1; proc p is q:= 3; Door de bovenstaande klasse declaratie wordt de env do uitgebreid met het volgende tupel: De y wordt eerst geëvalueerd en vervolgens in het environment opgeslagen, dit wordt nader besproken in 3.4. O n x 3 p q:= 3; y 4 T3 in het Wild While 6

8 3.1.4 Heap Alle instantiaties van gedeclareerde objecten slaan we op in een heap h. Het instantiëren van objecten gebeurt alleen in S. Het verschil met de Env do is dat de velden van de objecten kunnen veranderen naar aanleiding van Statements die worden uitgevoerd op deze velden. In tegenstelling tot de Env do waar de waardes van de velden niet meer veranderen na declaratie. Verder onderscheid is het ontbreken van de body s van de procedures in de heap. Deze kunnen worden opgezocht in de Envdo, wanneer er een call wordt aangeroepen. Door middel van de O name kan worden beoordeeld van welk type het object is en welke procedures dit type heeft. Dit levert een besparing op van het geheugengebruik omdat alle procedures maar op één plek worden opgeslagen. Formeel gezien: h : Oname (Otype x State) o1 O2 X 1 o2 O1 Y 6 X 3 Omdat de heap kan worden gezien als een resultaat van het programma hebben we besloten de heap te beschouwen als een state in plaats van een environment. Voorbeeld 3.2:.. class O n is var x:= 3; var y:= this.x + 1; proc p is q:= 3; object o:= new O n ;.. Bovenstaande toevoeging levert de volgende heap op: o O n x 3 y 4 T3 in het Wild While 7

9 3.1.5 Env this Tot slot slaan we het huidige object waarin gewerkt wordt op in Env this. Zodoende kunnen we na elke call op een object procedure precies terugvinden in welke object we werken. Bij het uitvoeren van een Statement van een object procedure kunnen we nu de this.veldnaam en of this.procedurenaam evalueren. Na het uitvoeren van een call staat de env this weer op de waarde voorafgaand aan de call. (zie ook upd this ) Env this : O name Voorbeeld 3.3:.. class O n is var x:= 3; var y:= 4; proc p is this.y := 1; object o:= new On; call o.p;.. Bij de aanroep van o.p is bekend dat o het huidige object is en zodoende kan dus de procedure p worden uitgevoerd en de y-waarde van de instantie o in de heap op 1 worden gezet. 3.2 Uitbreiding van de Semantiek van A & B Het is noodzakelijk dat we de semantiek van aritmetische expressies (A) aanpassen aan de uitbreiding van de syntax van a. De heap en env this zijn namelijk nodig voor het evalueren van de expressies o.v en this.v. Signatuur: A: Aexp ( State x heap x env this Z ) We schrijven één regel van de bestaande regels uit, de overige laten we aan de verbeelding van de lezer over. A [n] s h env this = N [n] De volgende regels hebben we toegevoegd: A [o.v] s h env this = p 1 (h o ) v A [this.v] s h env this = p 1 (h env this ) v T3 in het Wild While 8

10 Nu rest ons nog de aanpassing van de booleaanse expressies (B), die natuurlijk verandert aangezien de signatuur van A is veranderd en deze afhankelijk is van A. Signatuur: B: Bexp ( State x heap x env this T ) We schrijven wederom één bestaande regel uit. B [ a1 = a2 ] s h env this { tt if A [ a1 ] s h env this = A [ a2 ] s h env this { ff if A [ a1 ] s h env this? A [ a2 ] s h env this 3.3 State transitie Aangezien de toegevoegde environments en de heap ook dienen te worden verwerkt in de state overgangen hebben wij de oude state transitie gemodificeerd. De aangepaste state transitie ziet er als volgt uit: env this, env do, env p + < S, s, h > ( s, h ) 3.4 Update object declaratie In deze paragraaf zullen we de update functies behandelen die ervoor zorgen dat de environments ook daadwerkelijk worden aangepast bij object declaraties. Update van de env do, bij het declareren van objecten (in D o in R): upd do ( class O is D v D p ; D o, env do, state g 1 ) = upd do (D o, env do [ O ( upd v ( D v, lege state,state g, O), upd p ( D p, lege env p ) ) ], state g ) upd do (e, env do,state g ) = env do In bovenstaand gedeelte maken we gebruik van de functie upd v die de velden van het gedeclareerde object instelt op de begin waarde en de functie upd p die de procedures in de environment opslaat. Upd p heeft de vertrouwde vorm zoals bekend is van While. Update van de initiële waarden van de velden in env do : updv (var x:= a; Dv, state,stateg, Ocur) = updv (Dv, state [x env this leeg],state g, O cur ) where t = a [ this.v p 0 (env do O cur ) v ] A[t ]stateg hleeg 1 state g = de globaal bekende state (s) T3 in het Wild While 9

11 upd v (e, state,state g, O cur ) = state Opmerking: t is de Aexp a met daarin alle voorkomens van this.v s vervangen door de numerieke waarde van v in het huidige object (Ocur) dat nu in de declaratie fase is. Update van de procedures in env do : upd p (proc p is S; D p, env p ) upd p (D p, env p ) upd p (e, env p ) = env p Tenslotte moeten we de env this kunnen aanpassen. Hiervoor introduceren we de triviale functie upd this. Update van env this : upd this ( O name, env this ) = env this O name 3.5 State transitie bij object initialisatie Doordat de objectinstantiaties bijdragen tot een verandering van de heap en niet tot een verandering in een environment moeten deze beschreven worden door middel van state transities. D d ::= object o : = new O ; D d e [object ns ] env do + < D d, s, h [ o ( O, t) ] > d (s, h ) where t = p 0 (env do O) env do + < object o := new O ; D d, s, h > d (s, h ) [noneobjc ns ] < e, s, h > d ( s,h) env do dwingt af dat er geen objecten geïnstantieerd kunne n worden die niet gedeclareerd zijn. Dit komt doordat het een partiële functie is. Alle objecten die geïnstantieerd worden moeten dus voorkomen in env do. Nu moet er nog een nieuwe functie worden geïntroduceerd die de geïnstantieerde objecten opruimt. De functie DD(D d ): T3 in het Wild While 10

12 DD( object o := new O; D d ) = { o } U DD(D d ) DD( e ) = ø Deze functie draagt zorg voor het terugzetten van object instantiaties naar oude waarde bij het verlaten van de huidige scope (block). Zie ook de definitie van block ns en R blockns. We hebben in paragraaf 3.2 de semantiek van A aangepast. Dit leidt ertoe dat we de transitie van D v ook iets dienen aan te passen. Transitie van D v in state g : [var ns ] < D v, s [x A [a] s h ], h > v (s, h) < var x := a ; D v, s, h > v (s, h) [nonevarns] < e, s, h > v ( s,h) Aangezien de state s wordt aangepast bij het verwerken van D v hebben we besloten om hier ook een state transitie te gebruiken in plaats van een update functie, zoals upd v waarbij de env do wordt aangepast. De functie DV(D v ) zullen we niet uitschrijven, aangezien er niks veranderd is. T3 in het Wild While 11

13 3.6 NS Semantiek Hieronder volgen de toegevoegde semantiekregels, de regel [skip ns ] hebben we uitgeschreven om aan te geven hoe de overige regels eruit komen te zien. Behalve de signatuur verandert daar verder niks wezenlijks aan. [R block ns ] < D v, s, h> v (s,h), upd p (D p, env p ), upd do (D o, env do, s) + < D d, s, h > d ( s, h ), env this, env p, env do + < S, s, h > ( s, h ) env this, env p, env do + < Begin D v D p D o D d S End, s, h > (s [DV(D v ) s], h [DD(D d ) h] ) [S block ns ] < D v, s, h> v (s,h), upd p (D p, env p ),env do + < D d, s, h > d ( s, h ), env this, env p, env do + < S, s, h > ( s, h ) env this, env p, env do + < Begin D v D p D d S End, s, h > (s [DV(D v ) s], h [DD(D d ) h] ) [call o.p ns ] env do,upd this (o, env this ), env p + < S, s, h> ( s, h ) where S = p 1 (env do p 0 (h o ) ) p env do, env this, env p + < call o.p, s, h > ( s, h ) [call this.p ns ] env do, env this, env p + < S, s, h> ( s, h ) where S = p 1 (env do p 0 (h env this ) ) p env do, env this, env p + < call this.p, s, env do, env this, env p h > ( s, h ) [ass this.v ns ] env do, env this, env p + < this.v := a, s, h > ( s, h[p 1 (h env this ) v A[a] s h env this ] ) [ass o.v ns ] env do, env this, env p + < o.v := a, s, h > ( s, h[p 1 (h o) v A[a] s h env this ] ) [skip ns ] env do, env this, env p + < skip, s, h > ( s, h ) T3 in het Wild While 12

14 3.7 Voorbeeld begin 1 class O is var y:=1 ; proc p is this.y:= this.y + 2; 2 object o1 = new O; 3 call o1.p ; 4 x := o1.y; 5 end Het resultaat hiervan is dat x de waarde 3 krijgt/ heeft. Ad regel 1: Class O wordt gedeclareerd en toegevoegd aan de env do. env do [ O ( y 1, p this.y:= this.y + 2; ) ] Ad regel 2: Object o1 wordt geïnstantieerd met de velden van O en wordt toegevoegd aan de heap. h [ o1 ( O, y 1) ] Ad regel 3: De body wordt uitgevoerd met this vervangen door de update waarde van env this : o1.y := o1.y +2 ; Resultaat van dit statement is dat het veld o1.y ingesteld wordt op 3, in de heap. env this o1 h [ o1 (O, y 3) ] Ad regel 4: De waarde van het veld o1.y wordt toegekend aan x. s [x 3] Ad regel 5: Alle geïnstantieerde objecten (o1) worden teruggezet op hun oorspronkelijke waarde. T3 in het Wild While 13

15 4. Inheritance Er zijn ve rschillende manieren om inheritance (overerving) van klassen te implementeren. Een manier is om in een subklassen alle velden en procedures (methoden) van de superklasse(n) te kopiëren, zodat er precies kan worden gezien welke velden en procedures er gebruikt kunnen worden. Gedeclareerde velden en procedures in de subklassen worden hier dan ook toegevoegd en als er dan velden en/of procedures opnieuw worden gedeclareerd (door middel van dezelfde naam als in de superklasse), wordt het veld of procedure van de superklasse overschreven. Het nadeel van deze implementatie is dat het nogal veel geheugengebruik heeft. Een andere manier van implementatie is dat er geen informatie van superklasse(n) in een subklasse wordt gekopieerd. Wanneer er dan een veld op procedure wordt aangeroepen, wordt eerst gekeken of dit voorkomt in de subklasse. Als dit niet het geval is, wordt er teruggezocht in de superklasse en dit patroon kan zich dus herhalen als er meer superklassen zijn. Hier is er geen sprake van overhead in het geheugengebruik. Hierbij is het eleganter dat de velden van de superklasse(n) in de subklasse gekopieerd worden (al dan niet overschreven), omdat dan de object initialisatie hetzelfde blijft. Deze tweede implementatie is mooier dan de eerste en we proberen dus ook deze implementatie te realiseren in het vervolg van dit hoofdstuk. 4.1 Syntax Als eerste zal de syntax van While OO moeten worden uitgebreid. Dit kan eenvoudig door alleen D o aan te passen: D o ::= class O is D v D p ; D o class O is subclass O super D v D p ; D o e Waar O super de superklasse is, waarvan overgeërfd wordt. T3 in het Wild While 14

16 4.2 Semantiek In de semantiek zal meer aangepast moeten worden, de Envdo wordt namelijk uitgebreid. Dit heeft het gevolg dat de grootste veranderingen in de update functie van Env do zullen zitten Env do uitbreiden Bij elk gedeclareerde object moet nu ook een eventueel O type van de superklasse bijgehouden worden, zodat bij een procedure aanroep er omhoog gezocht kan worden in de klassenstructuur naar deze procedure. Formeel gezien: Env do : O type (O type x State x Env p ) O type O type State Env p O1 e X 3 P body Y 5 q body Voorbeeld 4.1:.. class O 1 is var x = 3; var y = 5; proc p is this.x = 5; proc q is this.y = 3; O2 O1 X 1 P body Y 5 class O2 is subclass O1 var x = 1; proc p is this.x = 3; object o2 := new O2; call o2.q;.. Deze aanroep is dus correct en zal de procedure q uit klasse O1 uitvoeren en zal dus de waarde van y in klasse O2 op 3 zetten Update functie Als eerste zal een klasse, die geen subklasse is, worden herschreven: upd do ( class O is D v D p ; D o, env do, state g ) = upd do ( class O is subclass e D v D p ; D o, env do, state g ) T3 in het Wild While 15

17 Hierdoor kan de echte update in de onderstaande regel worden gedaan. Hier worden ook twee hulpfuncties geïntroduceerd, namelijk upd p en upd v. De functie upd p verandert niet, maar het opzoeken van procedures zal later nog behandeld worden. upd do ( class O is subclass O super D v D p ; D o, env do, state g ) = upddo (Do, envdo [ O ( Osuper, upd v ( D v, lege state, state g, O, O super ), upd p ( D p, lege env p ) )], state g ) Als D o leeg is, wordt de geupdate env do opgeleverd: upd do (e, env do,state g ) = env do De functie upd v : Omdat de velden van alle superklassen overgeërfd moeten worden, gaan we alle velden van de superklassen kopiëren. Om ervoor te zorgen dat overschrijving van velden wel mogelijk is, zullen we recursief naar de top/root/pater familias-klasse zoeken en vervolgens op de terugweg alle velden kopiëren naar de nieuw te declareren klasse. Op deze wijze worden velden die door een superklasse zijn aangemaakt, indien nodig overschreven door de declaratie waarden van subklassen. Schematisch: T3 in het Wild While 16

18 Het algoritme voor de upd v functie in pseudo-code: functie update (O cur, O super ) { if (O super = = leeg) //root is leeg voegtoe_d v (O cur ) else //root is niet leeg update (O super, O super ) //recursie voegtoe_d v (O cur) //backtracking } functie voegtoe_dv (O cur ) { if (D v van O cur = = leeg) return //D v leeg, dan stoppen } else voeg eerste element van D v van O cur toe aan de nieuwe state voegtoe_dv (D v van O cur zonder eerste element) Ten slotte de aangepaste upd v functie: upd v (var x:=a; D v, state, state g, O cur, e) = //root is leeg upd v (D v, state [x A[t]state g h leeg env this leeg], state g, O cur, e ) //voegtoe_d v where t = a [ this.v p 1 (env do O cur ) v ] upd v (var x:=a; D v, state, state g, O cur, O super ) = merge (upd v (var x:=a; D v, state, state g, O super, p 0 (env do O cur )), upd v (var x:=a; D v, state, state g, O cur, e ) ) upd v (e, state, state g, O cur, e) = state //root is niet leeg //recursie //backtracking //D v leeg, dan stoppen NB: De functie merge doet het volgende: State1 x State2 State[voeg alle variabelen uit State1 samen met alle variabelen uit State2, waarbij indien de variabelenaam in State1 al bestaat deze overschreven wordt door de waarde in State2] 4.3 Object Initialisatie De object initialisatie verandert niet, omdat we alle velden weer overnemen vanuit de gedeclareerde klasse en we de procedures gaan opzoeken indien er een aanroep (call) wordt uitgevoerd. T3 in het Wild While 17

19 4.4 Semantiekregels Alle semantiekregels blijven hetzelfde, behalve de [call o.p ns ] en [call this.p ns ]. Merk op dat de upd do functie bij de regel [R block ns ] de aangepaste functie uit hoofdstuk is. [call o.p ns ] env do,upd this (o, env this ), env p + < S, s, h> ( s, h ) where S = lookup(p 0 (h o), p) env do, env this, env p + < call o.p, s, h > ( s, h ) [call this.p ns ] env do, env this, env p + < S, s, h> ( s, h ) where S = lookup(p 0 (h env this ), p) env do, env this, env p + < call this.p, s, env do, env this, env p h > ( s, h ) De functie lookup: lookup: (O type x P name ) Statement lookup ( o, p) = If (! Exists (p 2 (env do o), p) ) Then lookup ( p 0 (env do o ), p) Else p 2 (env do o ) p De functie Exists: Exists: (Env p x P name ) Boolean Exists geeft true terug als de P name in Env p voorkomt en false als P name niet in Env p voorkomt. NB: Merk op dat p 2 (env do o )p een p kan proberen op te zoeken die niet bestaat. Het is dan niet duidelijk wat de partiële functie Env p gaat opleveren en daarom hebben we de functie Exists geïntroduceerd. Deze functie werken we niet verder uit. T3 in het Wild While 18

20 4.5 Voorbeeld begin 1 class O1 is var y:=1 ; proc p is this.y:= this.y + 2; 2 class O2 is subclass O1 var x:=2; 3 object o2 = new O2; 4 call o2.p ; 5 y := o2.x; 6 z := o2.y; 7 end Ad regel 2: class O2 wordt gedeclareerd en toegevoegd aan de env do. env do [O2 (O1, (y 1, x 2), e )] Ad regel 3: Object o2 wordt geinstantieerd met de velden van O1 en O2 en wordt toegevoegd aan de heap: h[ o2 (O1, (y 1, x 2))] Ad regel 4: De body van p wordt opgezocht met de lookup functie. Deze wordt uit de superklasse O1 gehaald. Resultaat van het statement is dat het veld o2.y ingesteld wordt op 3 in de heap. Ad regel 5: De waarde van o2.x wordt aan y toegekend. Ad regel 6: De waarde van o2.y wordt aan z toegekend. T3 in het Wild While 19

21 5. Keywords Public & Private In het kader van dit werkstuk definiëren we de verschillende types velden en procedures als volgt: (conform de definities zoals gebruikt in Java). Public methoden & velden: - mogen buiten het object aangeroepen worden - mogen worden aangeroepen in subclasses van het object Private methoden & velden - mogen alleen worden aangeroepen binnen het huidige object - mogen niet worden aangeroepen binnen subclasses van het object De overige keywords aangaande methoden en velden zullen we buiten beschouwing laten (final, static, friend en dergelijke). 5.1 Syntax uitbreiding Om de syntax zo overzichtelijk mogelijk te houden en niet te veel af te wijken van het While OO hebben we de syntactische uitbreidingen tot een minimum beperkt. Bij het declareren van velden en methoden in klassen geven we enkel een extra indicator mee u (public) of i (private). Deze indicator kan alleen meegegeven worden bij velden en procedures in klassen. Voor reguliere velden en procedures heeft het geen zin deze indicator mee te geven, syntactisch wordt dit afgedwongen door een aangepaste D v1 en D p1 voor D o. ind::= u i D o ::= class O is D v1 D p1 ; D o e D v1 ::= var ind x := a ; D v1 e D p1 ::= proc ind p is S ; D p1 e T3 in het Wild While 20

22 5.2 Semantiek De State in env do zal aangepast moeten worden zodat deze een tupel oplevert met de Z waarde en een indicator. Ook de envp zal van een dergelijke constructie worden voorzien: Formeel gezien: State : V name ( Ind x Z ) Env p : P name ( Ind x Stm ) Env do : O type (State x Env p ) Schematisch: O x u 3 P i body y i 4 Q u body Voorbeeld 5.1:.. class O n is var i x:= 3; var u y:= this.x + 1; proc u p is q:= 3; In het bovenstaande voorbeeld maken we een class O aan in env do met private veld x, public veld y en public methode p. Bij een call o.p zal er alleen nog maar worden gezocht naar de public procedures ( welke dus een u indicator hebben). Zodoende kunnen er dus geen private procedures worden aangeroepen buiten de class. Voor de o.v geldt hetzelfde natuurlijk hetzelfde. Bij een this.v of een this.p is dit niet nodig omdat hier sprake is van een aanroep vanuit de class en dan mogen zowel private als public methoden / velden gebruikt worden. Overerving & public, private Indien er sprake is van overerving van classes zullen we een extra probleem moeten tackelen: subclasses erven geen private velden en methoden over. De oplossing voor de velden is eenvoudig, de nieuw geïntroduceerde upd v zal alleen nog maar de public velden van alle superclasses moeten kopiëren naar de State van een nieuwe subclass in env do, bij een object declaratie. Bij de initialisatie kunnen vervolgens weer alle velden in de heap worden gezet, dit zijn immers toch alle public velden. T3 in het Wild While 21

23 Bij de aanroep van procedures wordt het complexer, de lookup functie zal bij een call o.p de gevraagde procedure opzoeken. Er mag alleen gekeken worden naar public procedures, private procedures mogen alleen in de class worden aangeroepen. De functie lookup 2 : lookup2: (Otype x Pname) Statement lookup 2 ( o, p) = If (! Exists (p 2 (env do o), p)) Then lookup 2 ( p 0 (env do o ), p) Else If ( ispublic (p 2 ( env do o), p )) p 1 (p 2 (env do o ) p) De functie ispublic: ispublic: (Env p x P name ) Boolean ispublic geeft true terug als de Procedure p in Env p public is (de u indicator heeft) en false indien deze private is (i indicator). Indien call this.p wordt gebruikt zal eveneens de functie moeten worden opgezocht. Hier moet echter onderscheid gemaakt worden tussen een aanroep in een subclass of de originele class. Bij een subclass mogen geen private functies van de superclass worden aangeroepen. Om dit op te lossen kan een aparte lookup 3 gedefinieerd worden. Deze maakt geen onderscheid maakt tussen private en public procedures indien er niet gezocht hoeft te worden. Dit houdt in dat de functie in de eigen class is gedeclareerd en deze dus altijd aangeroepen mag worden. Indien de functie opgezocht moet worden in superclasses moet wel weer gecontroleerd worden, hiervoor kan de oude lookup 2 voor gebruikt worden. De functie lookup 3 : lookup 3 : (O type x P name ) Statement lookup 3 ( o, p) = If (! Exists (p 2 (env do o), p)) Then lookup 2 ( p 0 (env do o ), p) Else p 1 ( p 2 (env do o ) p) T3 in het Wild While 22

24 5.3 Semantiekregels Het enige dat verandert aan de semantiekregels is de wijze waarop de procedurebody wordt opgezocht. [call o.p ns ] env do,upd this (o, env this ), env p + < S, s, h> ( s, h ) where S = lookup 2 ( p 0 (h o ) p) env do, env this, env p + < call o.p, s, h > ( s, h ) [call this.p ns ] env do, env this, env p + < S, s, h> ( s, h ) where S= lookup 3 ( p 0 (h env this ) p) env do, env this, env p + < call this.p, s, env do, env this, env p h > ( s, h ) T3 in het Wild While 23

25 6. Geneste objecten In onze eerste implementatie hebben we ervoor gekozen om alleen aan het begin van het programma object declaraties toe te staan. Dit leidde ertoe dat er geen objecten gedeclareerd konden worden in een object. Dit is iets wat in een gangbare OO taal wel kan. Vandaar dat we in dit hoofdstuk de extra moeilijkheden zullen beschrijven die deze uitbreiding met zich mee brengt. We zullen tevens een aanzet geven tot een concrete uitwerking ervan. Hetzelfde zullen we doen voor het instantiëren van objecten in objecten. Denk hierbij aan een Java klasse waarin als veld een andere klasse zit. 6.1 Syntax De R regel in de syntax die we in hoofdstuk 2 hebben toegevoegd kan uit de syntax verdwijnen. De S verandert iets: S::= begin D v D p D o D d S end We hebben ervoor gezorgd dat er in een Statement nu dus ook objecten kunnen worden gedeclareerd. Dit heeft echter enkele verdere gevolgen voor de syntax. Je wilt deze geneste objecten ook kunnen benaderen. Er moet dus bijvoorbeeld een call o.o.o.p mogelijk worden gemaakt. Maar ook een call this.o.o.p Hiervoor introduceren we een semantische regel O*. Deze regel produceert een reeks van nul of meer o. s: O* ::= o.o* e De regel kunnen we als het volgt in de andere syntax regels verwerken: a::=.. o.o*v this.o*v S::=. call o. O*p call this. O*p o. O*v := a this. O*v := a Voor het instatiëren van objecten in objecten moeten we ervoor zorge n dat de regel D o worden aangepast zodat hierin ook object instantiaties kunnen voorkomen: D o ::= class O is D v D d D p ; D o e 6.2 States en environment We hebben er nu voor gezorgd dat syntactisch objecten in objecten kunnen worden gedeclareerd en geinstantieerd. We zullen hiervoor extra informatie moeten bijhouden in de states en evironments. T3 in het Wild While 24

26 Allereerst zal voor het bijhouden van geneste object declaraties de env do worden veranderd. Elk gedeclareerd object heeft nu een eigen lokale env do van objecten die in hem zijn gedeclareerd. De signatuur verandert dus als volgt: Env do : O type (State x Env p x Env do ) Een soortgelijke aanpassing is nodig voor de heap. Er moet in de heap nu bij elk geïnstantieerd object ook een lokale heap worden toegevoegd. In de geneste heap worden de geïnstantieerde objecten in dit object opgeslagen. De signatuur van de heap verandert als volgt: h : O name (O type x State x h) De update functies zullen nu vanzelfsprekend ook veranderen en worden uitgebreid, maar daar zullen we geen aandacht aan schenken. Het updaten wordt ingewikkelder, maar er verandert niks wezenlijks aan de vorige hoofdstukken. Het zou meer van het zelfde worden. 6.3 Semantiek We zullen ons wat betreft het uitbreiden van de semantiek vooral richten op het correct afhandelen van de punt operator. Dit aangezien de andere veranderingen vooral gebaseerd zullen zijn op het juist aanroepen van de update functies. Het probleem zit hem in het elegant afhandelen van de O* regel. Deze moet er voor zorgen dat je door de geneste structuur in de heap en de env do kunt zoeken. Hiervoor zien wij twee mogelijkheden: 1. We kunnen een functie definiëren die onder andere de gehele O* regel als argument mee krijgt. De finesse van het opzoeken verschuiven we op deze manier naar deze functie. Dit werkt in principe natuurlijk prima, maar vinden we niet elegant. 2. Een ander alternatief is dat we een nieuwe environment introduceren die een O name oplevert. Vergelijkbaar met de env this. Het idee is dat we deze environment als een soort pointer door de geneste structuur laten lopen bij het van vooraf aan uitlezen van o s van de O* s. Uiteindelijk hoef je alleen maar een functie te maken die een naam en een pointer naar de geneste structuur meekrijgt en dat wat je zoekt oplevert. Dit laatste vinden we een beter alternatief, omdat je zo tijdens het lezen van de o s al actie onderneemt. Iets wat je in het echt ook zou doen. Een nadeel is de nieuwe environment, wat op zich geen probleem is, maar die maakt de semantische regels wel een stuk minder leesbaar. T3 in het Wild While 25

27 Conclusie We hebben onderzoek gedaan naar de uitbreiding van de syntax en semantiek van de taal While met OO aspecten, te weten object declaraties en object instantiaties en we hebben de benodigdheden beschreven voor inheritance en geneste klassen. Het blijkt dat het niet eenvoudig is om OO te beschrijven in NS. Dat komt doordat er bij OO een heel samenhangend geheel van concepten komt kijken, zoals inheritence, keywords en geneste klassen. We hebben er eerst voor gekozen om het voor een eenvoudig geval te beschrijven, dat is vrij elegant gelukt. De uitbreidingen zijn echter ingewikkelder. Het blijkt dat er al gauw kunstgrepen worden toegepast zoals het uitbreiden van de environment of extra velden in state. Dat is op zich geen probleem, maar wanneer je alle concepten tegelijk wilt vangen in de semantiek, dan wordt het een onoverzichtelijk geheel. Wanneer we het puur OO zouden hebben gemaakt, dan was het waarschijnlijk eleganter geworden. Echter de kans bestaat dat we dan tegen andere problemen zouden aanlopen, die we nu nog niet overzien. Denk hierbij bijvoorbeeld aan een beginpunt van het uitvoeren (main functie). T3 in het Wild While 26