Rev**** Model Aanpassingen
Jaco Peeman en Casper de lange Februari 2003 SERC/UU
Abstract Dit document beschrijft de aanpassingen die gemaakt zijn aan het interne meta-model van het programma RevJava, geschreven door Gert Florijn. Het model is aangepast om naast Java ook .Net programma's in te kunnen lezen.
Index Abstract .......................................................................................................................... 2 Index............................................................................................................................... 2 Inleiding ......................................................................................................................... 3 Het generieke model...................................................................................................... 4 Het hart van het model: .............................................................................................. 4 GenType................................................................................................................. 6 GenClass ................................................................................................................ 7 GenInterface........................................................................................................... 7 GenField...............................................................................................................10 GenProperty .........................................................................................................11 GenEvent ..............................................................................................................12 GenNamespace .....................................................................................................13 DeploymentUnit...................................................................................................13 GenSystem ...........................................................................................................13 Het concrete deel van het model..............................................................................14 MSIL specifiek.............................................................................................................16 IlNameSpace ............................................................................................................16 IlTypes .....................................................................................................................17 IlClass...................................................................................................................18 IlInterface .............................................................................................................19 Feature......................................................................................................................20 IlMethod...............................................................................................................21 IlField ...................................................................................................................22 Java specifiek...............................................................................................................23 Verschillen met het oude model...................................................................................24 GenRepository .....................................................................................................24 GenSystem ...........................................................................................................24 GenNameSpace ....................................................................................................24 GenType...............................................................................................................24 Feature..................................................................................................................25 Variable ................................................................................................................25 Operation..............................................................................................................25 TaggedElement ....................................................................................................25 JTags ....................................................................................................................25
2
Inleiding RevJava is een programma dat programmeurs de mogelijkheid geeft Java byte -code in te lezen en hierop kritieken te laten uitvoeren. Hiervoor wordt er door RevJava een intern meta -model opgebouwd tijdens het inlezen. Het zou echter mooi zijn als RevJava toepasbaar was op meerdere (OO) talen. Hiervoor moest het meta-model aangepast worden. Dit document beschrijft het model van RevJava dat aangepast is zodat het ook geschikt is voor de Microsoft Intermediate Language (MSIL of IL). We moesten bij het ontwerpen van het model rekening houden met enkele belangrijke punten: •
• •
We moesten proberen het model zo generiek mogelijk te houden, omdat de critics in RevJava zo veel mogelijk op dat niveau uitgevoerd moeten worden. Tevens is een generiek model makkelijker wanneer er nog andere talen aan het model toegevoegd zouden moeten worden Gert Florijn had in zijn documentatie over RevJava een aantal mogelijke verbeteringen voor het model aangegeven, we hebben enkele daarvan doorgevoerd in het model (in overleg met Gert Florijn) Het model was erop gericht om type-gerelateerde regels op ingelezen code te kunnen loslaten en daarom waren niet alle aspecten van Java gerepresenteerd in het model. We moesten er rekening mee houden dat men deze in de toekomst eventueel wel zal willen toevoegen
Rekening houdend met bovenstaande punten zijn we als volgt te werk gegaan: • • • •
We hebben een onderzoek gedaan naar de grammatica van C# We hebben gekeken wat de verschillen tussen C# en de MSIL zijn door o.a. C# code te compileren en de MSIL daarvan uit te pluizen We hebben de MSIL specifieke punten onderzocht welke niet in C# zitten We hebben de verschillen en overeenkomsten bekeken tussen de MSIL en Java en de invloeden hiervan op het model bepaald
Er is gekozen om in eerste instantie uit te gaan van de C# grammatica, omdat de grammatica van C# in tegenstelling tot de MSIL prima gedocumenteerd was. Tevens is C# speciaal ontwikkeld voor .Net en beslaat een groot deel van de MSIL. De MSIL is echter generieker dan de MSIL die vanuit C# te compileren is, en wij moesten dus ook bepalen welke MSIL eigenschappen buiten de scope van C# liggen. Hierna konden we bepalen hoe het model er uit zou moeten zien om zowel voor Java als de MSIL geschikt te zijn. Uiteindelijk vonden we de ECMA specificatie van de MSIL en hebben we dit naast onze bevindingen gelegd om één en ander te checken.
3
Het generieke model De applicatie is gebaseerd op het inlezen van gecompileerde code. Met behulp van een parser voor de desbetreffende code wordt er een object structuur gevuld. Bij het ontwikkelen van het meta -model is zoveel mogelijk rekening gehouden met het inpassen van taal-plugins. Dit betekent dat een taal met zo weinig mogelijk moeite toegevoegd moet kunnen worden. Er is vooral onderzoek gedaan naar de entiteiten die in gecompileerde CSharp (MSIL code) en Java files (class files). Requirements op het generieke model: • Het model moet eenvoudig aanpasbaar zijn voor andere talen. Dit houdt in dat voor de algemeen in programmeertalen aanwezige entiteiten een model aanwezig is. • Het model moet een basis vormen om metrieken te kunnen berekenen. • Op de verschillende entiteiten moeten kritieken losgelaten kunnen worden. Eerst worden de entiteiten beschreven waarvoor voor elke taal plugin een subclass geschreven moet worden.
Het hart van het model: Feature GenType
* GenField * GenMethod innerclasses
*
outerclass
constructor 1..n
super 0..n
instance of
TypeRef
Figuur 1: Types
GenInterface
implementerende classes 0..n
GenClass
Interfaces 0..n
4
Het hart van het model bestaat uit classes, interfaces, methoden en fields. Dit zijn entiteiten die in alle object georiënteerde talen aanwezig zijn.
5
GenType Het type is de super van classes en interfaces. Het is nodig om deze class te herdefiniëren omdat een herdefinitie XDeploymentUnit van DeploymentUnit in een taal X een set van XTypes bevat. Het bevat de volgende fields: • GenNameSpace holder; een Type zit in precies 1 namespace. • GenField[] fields; types kunnen 0 of meer fields bevatten. • GenMethod[] methods; types kunnen 0 of meer fields bevatten. • GenMethod[] creators; de 0 tot n methoden waarin deze class geinstantieerd wordt. • GenMethod[] checkers; de 0 tot n methoden waarin deze class aangeroepen wordt. • GenMethod[] argDecls; 0 of meer argument declaraties. • GenMethod[] localDecls; 0 of meer lokale declaraties. • GenType[] knowingTypes; de 0 tot n types die dit type kennen. • GenType[] usingTypes; de 0 tot n types die dit type gebruiken. • GenType[] subclasses; de 0 tot n subclasses • GenType[] innerClasses; de 0 tot n innerclasses • GenType outerClass; de outerclass (0 of 1) • TypeRef[] usedTypes; de 0 of meer gebruikte types • TypeRef[] knownTypes; de 0 of meer bekende types: dus de gebruikte types maar ook de classes die bij de creators en checkers e.d. horen. • TypeRef superClass;
GenType knowing types 0..n
* GenField
using types 0..n subclasses 0..n
innerclasse s outerclas s
creators 0..n checkers 0..n arg decl 0..n locale decl 0..n
*
GenMethod
* gebruikte types 0..n
bekende types 0..n super 0..n
instance of
TypeRef
Figuur 2: Type
6
ElementTags
TaggedElementImpl
1
Interface TaggedElement
Interface GenType Figuur 2.1: GenType, TaggedElement en ElementTags TaggedElement is de superclass van GenType. TaggedElement bestond alleen uit een interface, dit willen we veranderen naar een interface TaggedElement en een class TaggedElementImpl die de interface implementeert. We kunnen dan op dit niveau aangeven dat een TaggedElement een ElementTags bevat, in plaats van dat GenType dit zelf moet declareren.
GenClass Een class bevat naast de fields van Type: • TypeRef[] interfaces: de door deze class geïmplementeerde interfaces (0 of meer). • GenMethod[] constructors: iedere class heeft tenminste één constructor. GenInterface Een class bevat naast de fields van Type: • GenClass[] implementors; de classes die deze interface implementeren.
GenMethod GenType constructor 1..n
GenInterface
implementerende classes 0..n
GenClass
Interfaces 0..n
TypeRef
Figuur 3: GenClass en GenInterface
7
Features Features zijn de bouwstenen waaruit een GenType is opgebouwd. Dit zijn dus over het algemeen methoden en fields. Een Feature heeft de volgende fields: • GenType holder; een feature is bevat in precies één type. • GenMethod reader; elke feature wordt door 0 of meer methoden gelezen.
Feature
readers 0..n
Variable
GenMethod
overwritten methods 0..n overrides methods 0..n
GenEvent
Argument *
fir e add
LocalVar *
remov e
CodeBlock GenProperty
get set
GenField
used types 0..n
known types 0..n
result type 0/1
heeft type 1
exceptions 0..n
writers 0..n
* Operation
TypeRef
Figuur 4: Feature, GenProperty, GenEvent, GenMethod en GenField. Feature is een subclass van TaggedElement (origineel JTaggedElement) net zoals JTypeElement dat origineel was. TaggedElement bestond echter alleen uit een interface, dit willen we veranderen naar een interface TaggedElement en een class TaggedElementImpl die de interface implementeert. We kunnen dan op dit niveau aangeven dat een TaggedElement een ElementTags bevat, in plaats van dat Feature dit zelf moet declareren.
8
ElementTags
1
TaggedElementImpl
Interface TaggedElement
Interface Feature
Figuur 4.1: Feature, TaggedElement en ElementTags
9
GenMethod Een methode bevat een CodeBlock. Dit CodeBlock bevat alle operaties en lokale variabelen van een methode. De fields die de klasse Method bevat zijn: • • • • • • • •
GenMethod overwrittenMethod: de methoden die door deze methode geherdefinieerd worden. GenMethod overridesMethod: de methoden die deze methode herdefiniëren.. TypeRef resultType; het return type(kan void zijn, of in het geval van een constructor niet aanwezig). TypeRef[] exceptions; de exceptions die afgevangen worden in de methode. TypeRef[] usedTypes; de types die in deze methode gebruikt worden. TypeRef[] knownTypes; de types die bekend zijn in de methode. GenArgument[] arguments; de parameters van de methode. CodeBlock codeblock;
GenField • TypeRef type; het type van het Field. • GenMethod[] writers; de methoden die dit field veranderen. • boolean isBuiltIn; is het een int, double, e.d.? • boolean isMultiple; is het een array? • boolean isPointer; is het een pointer?
10
GenProperty • TypeRef type; het type van de Property. • GenField field; het field dat bij de property hoort. • GenMethod get; • GenMethod set; Op dit moment zijn de properties in het model gespecificeerd naar de Properties die in de MSIL zitten. Wanneer er programmeertalen toegevoegd moeten worden met soortgelijke constructies kan er een subclass toegevoegd worden wanneer het niet in GenProperty past.
GenProperty
Interface Feature
Interface GenProperty get 0/1
Interface GenMethod
set 0/1 other 0/1
TypeRef heeft type 1 callers
1
Interface GenField
Figuur 5: GenProperty Een GenProperty is gedefinieerd voor een field X en bevat links naar een aantal GenMethods die op dat field werken: o een get_X() methode o een set_X() methode Minimaal één van deze twee moet aanwezig zijn anders is het een compile-time error. Verder kent een GenProperty nog een 'other' link die bedoeld is voor andere methodes die op het field werken en in een Property gedefinieerd kunnen zijn. Deze functie is in C# niet ingebouwd.
11
GenEvent • TypeRef type; het type van het Event. • GenMethod addon • GenMethod removeon; • GenMethod fire; Op dit moment zijn de events in het model gespecificeerd naar de Events die in de MSIL zitten. Waneer er programmeertalen toegevoegd moeten worden met soortgelijke constructies kan er een subclass toegevoegd worden wanneer het niet in GenEvent past.
GenEvent
Interface Feature
Interface GenEvent addon 0/1
Interface GenMethod
removeon 0/1 fire 0/1
TypeRef heefttype 1
other 0/1
callers 0..n
Figuur 6: GenEvent Een GenEvent bevat de methodes 'addon' en 'removeon', 'fire' en 'other' zijn optioneel. In C# is 'other' niet beschikbaar. Een event heeft een TypeRef naar een IlType waarvoor het gedefinieerd is. GenEvent en GenProperty geven aan dat we ervan uit gaan dat er ook nog events en properties in andere programmeertalen dan C# voorkomen. We hebben er nu voor gekozen om geen speciale subclass (b.v. IlProperty,IlEvent) aan te maken aangezien veel talen ook al naar MSIL gecompileerd kunnen worden en de talen dus binnen dit model passen. Als er toch een uitbreiding moet plaatsvinden voor het toevoegen van een andere taal is dit vrij eenvoudig te doen.
Het codebloc k, de operaties, de variabelen, de argumenten en lokale vars zijn voor alle talen hetzelfde
12
GenNamespace Een namespace is een groepering van types. Een namespace heeft een hiërarchische structuur die gebaseerd is op de naamgeving. De consequenties hierva n zijn niet voor alle programmeertalen gelijk dus het gedrag van de namespaces in een bepaalde taal zal in de plugin voor die taal gedefinieerd moeten worden. De members van een namespace zijn: • GenSystem holder; • GenType[] types; • GenNameSpace[] children; een namespace kan 0 of meer subnamespaces bevatten. Bij sommige talen (zoals Java) is deze relatie alleen gebaseerd op naamgeving en heeft verder geen consequenties. Bij C# kan een namespacemember van een geneste namespace bij de members van de parent-namespace (mits de tags op die members dat toe laat). • GenNameSpace parent; de namespace die deze namespace bevat. DeploymentUnit Een DeploymentUnit representeert de door de gebruiker gegroepeerde types zoals een jar file in Java of een assembly in dotNet. • GenType[] types; • GenNameSpace[] nameSpaces; GenSystem De System class kan meerdere DeploymentUnits bevatten. DeploymentUnit[] deploymentUnits; • GenNameSpace[] nameSpaces;
GenRepository
* GenSystem
* DeploymentUnit
*
*
GenNameSpace
* GenType
*
*
Figuur 7: GenNameSpace, DeploymentUnit, GenSystem
13
Het concrete deel van het model Naast de entiteiten die door een taal plug-in geherdefinieerd moeten worden, zijn er ook nog classes die geen herdefinitie door een plug-in vereisen. Dit zijn: • TypeRef: deze class representeert een re ferentie naar een type. In de UML diagrammen is te zien waar de typereferenties naar voren komen. GenType
Refereert
TypeRef • • • •
CodeBlock: de stack code, calls, casts e.d. van een methode. (zie GenFeature) LocalVar: de lokale variabelen in een CodeBlock. Argument: Deze class representeert de parameters van een methode. Operation en al zijn sub-classes: de operaties die uitgevoerd worden vanuit een CodeBlock.
CodeBlock
*
Operation
1
TypeOperation Method
heeft type 1
return waarde 0/1 verwacht type 1
roept aan 1
OpCall
parameters 0..n
TypeRef
OpCheck
OpCreate
OpFieldRef manipulatie van 1
Field
Figuur 8: TypeOperation 14
TypeOperation was origineel JTypeElementPart en was toen de superclass van OpCall, OpCheck, OpCreate, OpFieldRef en JVariable. We hebben gekozen om OpCall, OpCheck, OpCreate en OpFieldRef subclass te maken van TypeOperation welke op zijn beurt weer een subclass is van Operation. Wanneer er nu andere operaties toegevoegd moeten worden (return-statements b.v.) welke geen TypeOperation zijn kunnen deze een subclass worden van Operation.
15
MSIL specifiek Dit document gaat dieper in op de MSIL -specifieke elementen welke aan het generieke model zijn toegevoegd.
IlNameSpace De interface IlNameSpace is een subclass van GenNameSpace en representeert de namespaces welke in MSIL gedefinieerd kunnen worden. IlNamespaces zijn gedefinieerd in één of meerdere IlModules, welke bevat zijn in een IlAssembly.
IlNameSpace
Interface IlRepository
Interface IlSystem
*
Interface DeploymentUnit
* Interface IlAssembly Interface CritiquedElement Interface GenNamespace
* Interface IlModule
* Interface IlNameSpace
*
* Interface IlType
*
Figuur 9: IlNamespace Een IlAssembly bevat 1 of meerdere IlModules: gecompileerde units bestaande uit metadata en MSIL. De metadata beschrijft de structuur van de module. Een IlModule kan niet onafhankelijk bestaan maar moet bevat zijn in een IlAssemly. Een module kan ook globale methodes en fields bevatten, deze worden echter niet in het model opgenomen. Een IlNameSpace bevat IlTypes, maar kan ook sub-namespaces bevatten. De toplevel namespace die door de programmeur wordt gedeclareerd, wordt onderdeel van de global namespace. Sub-level namespaces worden onderdeel van de omvattende namespace. Wanneer er geen namespace door de programmeur is gedeclareerd staan de types in de global namespace.
16
De naam van een namespace impliceert niets over de directory structuur die wordt opgebouwd. In MSIL kan een module ook globale methodes en fields bevatten, deze worden momenteel in het model niet opgeslagen aangezien er nu nog niets mee wordt gedaan.
IlTypes We hebben ervoor gekozen om de interfaces IlClass en IlInterface een gezamenlijke super interface IlType te geven. Op deze manier kan men door het programma heen gebruik blijven maken van een algemeen type, met behoud van de informatie dat men op MSIL code aan het werken is. In het oorspronkelijke model van RevJava was dit al aanwezig d.m.v. JType, door de generalisering van het model is dit echter wat anders in het model geplaatst.
IlType Interface IlNameSpace
* Interface IlType knowing types 0..n
*
Interface IlField
*
Interface GenEvent
*
Interface GenProperty
using types 0..n subclasses 0..n
innerclasses
*
creators 0..n
outerclass
Interface IlMethod
checkers 0..n arg decl 0..n locale decl 0..n
gebruikte types 0..n
instance of
bekende types 0..n
super 0..n
Interface IlType
*
TypeRef
Figuur 10: IlType Een IlType kan IlFields, GenEvents, GenProperties en IlMethods bevatten. Er wordt bijgehouden wat de super- en sub-classes zijn van een IlType en of een IlType geneste classes bevat, of dat het zelf een geneste class is (in welk geval er een outerclass wordt opgeslagen). Alle bekende IlTypes worden bijgehouden en daarnaast ook een tabel waarin de IlTypes worden opgeslagen die door het IlType gebruikt worden.
17
IlClass In het onderstaande figuur is te zien dat IlClass subclass is van zowel IlType als GenC lass. Dit hebben we gedaan omdat dan het model dan generieker opgezet is. GenType is de superclass van GenClass en GenInterface. Een GenClass heeft door overerving via GenType en TaggedElement een object ElementTags waarin opgeslagen wordt welke tags op het type gedefinieerd zijn.
IlClass Interface IlType
Interface GenClass
Interface IlClass boolean isEnum, isStruct, isAttribute?? TypeRef
destructor 0/1
Interfaces 0..n
Interface IlMethod
constructor 1..n
Figuur 11: IlClass In een IlClass wordt bijgehouden of de class een Enum, Struct of Attribute is via het zetten van een flag. Tevens wordt er bijgehouden welke IlInterfaces door de class geïmplementeerd worden en of hij constructoren (de constructor zonder argumenten is altijd aanwezig) en een destructor methode definieert. Constructoren en destructoren worden bijgehouden als methode met een constuctor - of destuctor -flag die gezet wordt.
18
IlInterface Een IlInterface is net als IlClass een subclass van IlType, daarnaast is het nog een subclass van GenInterface. Ook een interface (IlInterfaceImpl) heeft een ElementTags waarin opgeslagen wordt welke tags erop gedefinieerd zijn. Tevens wordt bijgehouden welke IlClasses de interface implementeren.
IlInterface
Interface IlType
Interface GenInterface
Interface IlInterface implementerende classes 0..n
Interface IlClass
Figuur 12: IlInterface
19
Feature Feature is de oude JTypeElement van RevJava. GenMethod, GenField, GenEvent en GenProperty zijn sub-classes van Feature, GenMethod en GenField zijn nog gespecialiseerd naar Java en MSIL specifieke classes.
Feature ElementTags
1
TaggedElementImpl
Interface TaggedElement
Interface Feature
Interface GenMethod
Interface GenField
Interface GenEvent
*
*
Interface IlField
Interface IlMethod
*
Interface GenProperty
* Interface IlType
Figuur 13: Feature
20
IlMethod Een IlMethod bevat dezelfde elementen zoals aangegeven in het generieke model, alleen zijn readers, submethods en alle types (supertypes,resulttypes enz.) IlTypes. IlMethods kunnen als MSIL - specifieke tags 'Family' en 'FamAndAssem' op zich gedefinieerd hebben.
Interface Feature
IlMethod
Variable
Interface Variable Interface GenMethod Variable
Interface IlMethod Interface Argument
readers 0..n submethods 0..n supertypes 0..n
TypeRef
*
result type 0/1
Interface CodeBlock
exceptions 0..n used types 0..n known types 0..n
*
Interface LocalVar
Interface Operation
*
Figuur 14: IlMethod
Speciale IlMethods zijn de constructor, welke in MSIL 'ctor' wordt genoemd, en de static constructor welke in MSIL 'cctor' wordt genoemd.
21
IlField Een IlField heeft readers en writers van het type IlMethod. De TypeRef is een referentie naar een IlType. Ook een IlField heeft als specifieke tags 'Family' en 'FamAndAssem'.
Interface Feature
IlField
Interface GenField Variable
Interface IlField Interface IlMethod readers 0..n writers 0..n
TypeRef heeft type 1
Figuur 15: IlField
22
Java specifiek We hebben er naar gestreefd de MSIL in het model toe te voegen op zo'n manier dat er voor het oorspronkelijke Java model niet al te veel zou veranderen. Het model is op bepaalde punten generieker gemaakt, zodat de oorspronkelijke Java elementen iets anders in het model hangen, maar dezen zijn wat betreft gedrag niet wezenlijk veranderd. Dit was mogelijk omdat het ontwerp van het oorspronkelijke model al vrij generiek van opzet was. Hieronder staat het gehele model. Element
NamedElement
ElementTags
Operation
GenRepostitory
MethodTags CritiquedElement
JRepostitory
TypeTags TypeOperation
IlRepostitory
PropOrEventTags IdElement
VariableTags
IlModule
GenSystem
OpCheck FieldTags OpCall
GenNamespace
CodeBlockTags
IlSystem
JSystem
OpCreate OpFieldRef
TaggedElement
JPackage
IlNamespace DeploymentUnit
GenType
JJar
IlAssembly
CodeBlock
Feature
GenClass
GenInterface Variable
GenField
GenMethod
JClass
IlClass
JInterface
IlInterface LocalVar
JField
IlField
JMethod
Argument
IlMethod JType
GenProperty
IlType
GenEvent
Figuur 16: Complete model
23
Verschillen met het oude model De belangrijkste verschillen met het oude model worden hieronder behandeld: GenRepository GenRepository zit in het model op de plek waar eerst de JRepository zat, maar is slechts als generalisatie van JRepository en IlRepository toegevoegd. GenSystem GenSystem is de generalisatie van JSystem en IlSystem en zit in het model waar JSystem oorspronkelijk zat. GenNameSpace GenNameSpace is de generalisatie van JPackage en IlNameSpace. Tevens is het nu mogelijk geneste elementen hierin aan te geven. GenType We wilden aparte interfaces maken voor MSIL classes en Java classes en hadden daarbij twee opties (zie figuur): het aanmaken van een GenType, JType en IlType met daaronder de verschillende typesoorten, of het aanmaken van GenType, GenClass en GenInterface en dit nog verder gespecialiseerd. We kozen voor de laatste optie, omdat het model dan generieker van opzet bleef.
GenType
JType
JClass
IlType
JInterface
IlClass
IlInterface
Optie 1.
GenType
GenClass
JClass
IlClass
GenInterface
IlInterface
JInterface
Optie 2.
Figuur 17: GenType opties
24
Uiteindelijk hebben we JType en IlType toch nog toegevoegd, omdat in het model dan een algemeen type gebruikt kan waarbij toch bekend was dat het MSIL types betreft. Feature TypeElementPart is verandert in Feature omdat dit beter aangeeft wat de sub-classes hiervan voor de types betekenen. Oorspronkelijk waren alleen JMethod en JField subclasses, nu hebben we een generieke methode class GenMethod waarvan JMethod en IlMethod subclasses zijn. Tevens is er een generieke class GenField, waarvan JField en IlField de sub-classes zijn. Aangezien er in MSIL-types properties en events gedeclareerd kunnen worden zijn deze als GenEvent en GenProperty toegevoegd onder Feature. We gaan ervan uit dat ook andere tale n properties of events kunnen bevatten, wanneer dit niet onder te brengen is in GenEvent of GenProperty kan het model nog gespecialiseerd worden. Variable De oude JVariable hebben we opgesplitst in Argument en LocalVar, tevens is het Variable genoemd. We hebben Variable TaggedElement als superclass gegeven, omdat er op Arguments en LocalVars enkele tags mogelijk zijn. Operation In het oorsprokelijke model was er sprake van een TypeElementPart die de superclass was van de verschillende JOperation en JVariable. De subclasses van JOperation waren eigenlijk type -gerelateerde relaties, vandaar dat we de class TypeOperation hebben toegevoegd als superclass hiervoor. TypeOperation op zijn beurt is weer de subclass van Operation geworden, zodat er in de toekomst ook niet-type-gerelateerde relaties kunnen worden toegevoegd als subclass van Operation. TaggedElement TaggedElement was eerst alleen een interface maar hiervan willen we een interface met implementatie van maken, zodat er op dit niveau dan een ElementTags gedeclareerd kan worden die de subclasses van TaggedElement overerven. JTags JTags is veranderd in een implementatie structuur (zie figuur) in plaats van een enkele implementatie class, omdat we een verschil wilden maken tussen de verschillende soorten TaggedElements met hun tags. Voor sommige tags was de betekenis in MSIL en Java gelijkwaardig, enkele tags hebben we kunnen veralgemeniseren en beide talen hebben een aantal specifieke tags in het model. ElementTags MethodTags GenTypeTags FieldTags PropOrEventT CodeBlockTag Figuur 18: ElementTags
VariableTags
25
