SDA SE Wiki

Software Engineering for Smart Data Analytics & Smart Data Analytics for Software Engineering

User Tools

Site Tools


Command disabled: backlink

Programm-Element-Fakten

Diese Abschnitt stellt die Fakten AST-Darstellung vor, die im JTransformer-Framework verwendet wird.
Die Darstellung von Typen erfolgt durch sogenannte Typ-Terme. Dabei wird unterschieden zwischen Typ-Termen für Basic Types(double usw.) und Class Types(Klassen und Interfaces).
In Typ-Termen von Basic types wird als erstes Attribut basic eingesetzt:
type(basic, Typname) , num >= 0
bei Klassen und Interfaces:
type(class, #id, num) , num >= 0
num bezeichnet die Dimension eines Arrays. 0 steht für einfache Typen (kein array).
Im Folgenden stellt ein Argument TYPE immer einen Typ-Term dar.

Im Folgenden werden alle Programm-Element-Fakten (PEF) aufgeführt.
Zur besseren Unterscheidung sind die Argumente die eine Id darstellen mit einer '#' markiert. In der richtigen Prolog-Darstellung werden für die Ids Nummern eingesetzt. Id-Listen sind mit eckigen Klammern umschlossen.
Die Id #encl referenziert im folgenden immer die umschließende Methode. Eine Ausnahme stellen die Felddeklarationen, sieht Definition von fieldDefT.
Die Liste ist top down aufgebaut. Sie beginnt mit dem Package-Fakt, das Quelldateien enthält, die wiederum die imports, Klassen und Interfaces enthält usw.

Interface Elemente

packageT(#id, fullname)

stellt ein package dar. fullname ist hierbei der vollqualifizierte Name des package. packageT ist das einzige PEF, dass keinen Elternverweis besitzt.

toplevelT(#id, #package, 'filename', [def_1])

repräsentiert eine Quelldatei. def_1,… ist eine Liste von Ids, die importT und classDefT Fakten bestimmen.

importT(#id, #topLevel, #classid_or_packagename)

stellt eine import Anweisung dar. Das dritte Argument ist entweder eine Typ-Id, oder ein package Name. Im ersten Fall wird nur dieser Typ importiert, sonst das gesamte package.

classDefT(#id, #owner, name, [def_1,...])

stellt einen Objekt-Typ dar. Existiert das Fakt interfaceT(id) so handelt es sich um ein Interface, sonst um eine Klasse. Die Liste defs enthält Methoden (methodDefT/7) oder Felder (fieldDefT/6). Die Id #owner referenziert entweder ein Package, eine Klasse (inner class), oder eine Methode (anonyme Klasse).

methodDefT(#id, #classDef, name, [params], TYPE, [#exception_1,...], #body)

stellt eine Methode, einen constructor, oder einen initializer dar. Im Fall eines constructors ist name '<init>', bei einem initializer gleich '<clinit>' und bei Methoden gleich dem Methodennamen. Die Ids in der Liste params bestimmen die Methodenparameter, die durch varDefT Fakten dargestellt werden.

localDefT(#id, #parent, #enclClass, TYPE, name, #init)

Die #init ist entweder gleich null, oder verweist auf einen initialisierenden Ausdruck.

fieldDefT(#id, #class, TYPE, name, #init)

stellt eine Feld Deklaration dar.

paramDefT(#id, #method, TYPE, name)

stellt die Deklaration eines Methoden-Parameters dar.

Code Elemente

blockT (#id, #parent, #encl, [stmt_1,stmt_2,...])

stellt einen Methodenrumpf, oder ein Unterblock des Rumpfes, z. B. ein then, oder else Zweig einer if Verzweigung dar. Die Liste stmt_1,stmt_2,… stellt die Ids der im Block enthaltenen Statements dar.

getFieldT(#id, #parent, #encl, #expr, name, #field)

stellt den Zugriff auf ein Feld dar. Erfolg der Zugriff auf einem Ausdruck,so wird dieser mit #expr identifiziert. Bei einem impliziten Feldzugriff ist #expr gleich 'null'.

identT (#id, #parent, #encl, name, #symbol)

stellt einen Zugriff auf eine die umgebende Instanz (this), eine lokale Variable, den Zugriff auf einen Methodenparameter oder die statische Auswahl eines Typs dar. name benennt lokale Variable, oder Typnamen und #symbol ist die ID der referenzierten Klassen oder Variablen Deklaration.

selectT (#id, #parent, #encl, name, #selected, #symbol)

stellt eine member class Auswahl auf einem Typ Ausdruck dar. Die Id #selected spezifiziert den Typ Ausdruck auf dieser Zugriff erfolgt. Die selectT PEFs können geschachtelt werden, wobei dann die Id #selected wiederum eine selectT referenziert.

literalT (#id, #parent, #encl, TYPE, value)

stellt ein Literal dar. Literale in Java sind die Werte von basic types und Strings. value wird bei allen Typen in Hochkommata angegeben, z. B. '1', '0.1', 'c', 'val'. TYPE spezifiziert um welchen Typ es sich handelt. Im gegensatz zum Orginal werden wir das “null”-Literal auch als solches angeben!

assignT (#id, #parent, #encl, #lhs, #rhs)

stellt eine Zuweisung auf ein Feld- oder eine lokale Variable dar. Hierbei referenziert #lhs (Left Hand Side) das Feld bzw. die Variable und #rhs (Right Hand Side) den Ausdruck der zugewiesen wird.

applyT (#id, #parent, #encl, #expr, name, [#arg_1,#arg_2,..], #method)

stellt einen Methodenaufruf dar. #expr referenziert einen Ausdruck an den der Methodenaufruf gesendet wird. Die Liste #arg_1,#arg_2,.. geben die Ids der Argument Ausdrücke an. #method stellt die referenzierte Methode dar.

newClassT (#id, #parent, #encl, #constructor, [#arg_1,#arg_2,..], #typeExpr, #def, #enclosing)

stellt einen constructor Aufruf oder die Definition einer anonymen Klasse dar. Im ersten Fall verweist #constructor auf die Id des verwendeten constructors. Die Liste #arg_1,#arg_2,.. gibt die Ids der übergebene Argumentenausdrücke an. Handelt es sich um den Aufruf eines inner oder member class constructors, so wird mit #enclosing die Id diese Klasse übergeben. Im zweiten Fall wird die Id der anonymen Klassendefinition (einer classDefT) übergeben.

  1. typeExpr ist ein identT oder selectT, das im Fall von selectT einen voll qualifizierten Typ-Namen beschreibt und bei identT einen einfachen Typnamen beschreibt.

newArrayT (#id, #parent, #encl, [#dim_1,#dim_2,..], [#elem_1,#elem_2,..], TYPE)

steht für die Erzeugung eines Arrays. Die Ids #dim_1,#dim_2,.. spezifizieren Ausdrücke, die die Größe der einzelnen Dimensionen anzeigen. Die Liste #elem_1,#elem_2,.. gibt Initialisierungselementen an. Ist das Array mehrdimensional, so verweisen die #elem_1 Ids wiederum auf newArrayT PEFs. BEACHTE: Diese Definition wurde verändert. TYPE gibt nun den Typ des Arrays selbst an, als bei einem zweidimensionalen int-Array müßte er type(basic, int, 2) lauten!

execT (#id, #parent, #encl, #expr)

ist ein Wrapper für Ausdrücke die im Kontext eines Statements verwendet werden. z. B. für Methodenaufrufe in einem Block (blockT). Die Id #expr den auszuführenden Ausdruck.

throwT (#id, #parent, #encl, #exec)

stellt das Werfen einer exception dar. Die Id #exec spezifiziert die zu werfende Exception (also typischerweise einen newClassT-Fakt, der die Exception erzeugt)

returnT (#id, #parent, #encl, #expr)

stellt das return Konstrukt dar. #expr ist der Ausdruck, der zurückgegeben wird.

breakT (#id, #parent, #encl, label, #target)

stellt das Keyword break in Java dar. Die Id #target gibt an welches Element im AST angesprungen wird. Wenn label gleich 'null' ist, verlässt die Abarbeitung den direkt umschließenden Block, sonst den umschließenden Block der mit label markiert ist. Im falle eines switch-Blockes zeigt #target auf das switchT.

continueT (#id, #parent, #encl, label, #target)

stellt das keyword continue in Java dar. Die Id #target gibt an welches Element im AST angesprungen wird. Ist label gleich 'null' ist #target die umschließende Schleife (do, for, while), sonst die mit label markierte Schleife.

doLoopT (#id, #parent, #encl, #condition, #body)

stellt eine do while Schleife dar. Die Id #condition zeigt auf die auszuwertende Bedingung, die Id #body auf den Schleifen Block.

whileLoopT (#id, #parent, #encl, #condition, #body)

stellt eine while Schleife dar. Die Id #condition zeigt auf die auszuwertende Bedingung, die Id #body auf den Schleifen Block.

forLoopT (#id, #parent, #encl, [#init_1,...], #condition, [#step_1,...], #body)

stellt eine for Schleife dar. Die Id Liste #init_1,… zeigt auf die Ausdrücke der Initialisierungen. Die Id #condition zeigt auf die auszuwertende Bedingung. Die Liste #step_1,… zeigt auf eine Liste von Ausdrücken, die nach jeder Iteration durchgeführt werden. Die Id #body den Schleifen Block.

labelledT (#id, #parent, #encl, #body, name)

stellt ein Label dar. #body kann hierbei entweder ein Block, oder eine Schleifendefinition sein (do, for, while). Das letzte Argument name gibt den Namen des Labels an.

switchT ''(#id, #parent, #encl, #condition, [#statements])''

stellt ein Switch Statement dar. Die Bedingung #condition wählt einen der caseT's aus, die in der Liste der[#statements] enthalten sind. Es handelt sich bei ihnen um caseT Pseudo-Statements.

caseT (#id, #parent, #encl, #label)

ist eine Element des Switch Statements. Es dient als Einsprungspunkt für sein switchT, das gleichzeitig sein #parent ist. Alle nachfolgenden Statements werden ausgeführt, bis ein break erreicht wird. Sollte #label null sein, so handelt es sich um den default-case

synchronizedT (#id, #parent, #encl, #lock, #body)

leitet eine synchronisierten Block (#body) ein. Hier bei ist #lock eine Referenz auf eine Instanz, die exklusiv gesperrt werden soll.

tryT (#id, #parent, #encl, #body, [#catcher], #finalizer)

leitet eine Try Catch Block ein.

catchT (#id, #parent, #encl, #param, #body)

stellt ein Catch-Element dar.

ifT (#id, #parent, #encl, #condition, #thenPart, #elsePart)

stellt eine if-Anweisung dar.

conditionalT (#id, #parent, #encl, #condition, #thenPart, #elsePart)

stellt eine Bedingung dar. Java Syntax: #condition ? #ifPart : #thenPart.

operationT (#id, #parent, #encl, [#args], operatorName, pos)

steht für alle in Java mögliche unären, und binären Operationen. Hierbei ist operatorName gleich !,+,-,/,*,«,….

typeCastT (#id, #parent, #encl, TYPE, #expr)

stellt ein Cast des Ausdrucks #expr auf den Type TYPE dar.

typeTestT (#id, #parent, #encl, TYPE, #expr)

stellt die instanceof Operation dar.

indexedT (#id, #parent, #encl, #index, #indexed)

ermittelt in einem Array (#indexed) die Position #index.


Folgende Regeln stellen Beziehungen zwischen PEFs und Attribute von PEFs dar:

interfaceT (#class)

markiert ein classDefT PEF als interface.

extendsT (#class, #extendedClass)

stellt die Vererbungsbeziehung zwischen zwei Typen dar.

implementsT (#class, #interface)

stellt die implements Beziehung zwischen einer Klasse und einem Interface dar.

externT (#class)

markiert eine Klasse als nicht im Sourcecode vorliegende Klasse. Diese Klassen liegen in der in der Faktenbasis nur auf Interface-Ebene vor, d. h. alle Methodenrümpfe und Feldinitialsierungsfakten sind nicht in der Datenbasis enthalten.

modifierT (#id, modifier)

stellt die Verknüpfung von java modifiers(public,static, u.s.w) mit Objekt-Typen und Objekt-Typ-Elementen dar.

=== assertT (#id, #parent, #enc, #condition) === stellt eine (in java 1.4 eingeführte) assert-Anweisung dar. Dies ist wie ein ifT zu sehen, nur ohne then und else-blöcke

nopT(#id, #parent, #enc)

stellt eine leere Anweisung im momentanen Block dar.

assignopT(#id, #parent, #encl, #lhs, operator, #rhs)

stellt eine Zuweisung auf ein Feld- oder eine lokale Variable mit operation operator (wie +=, -=…) dar Dabei ist operator der Teil vor dem =. Hierbei referenziert #lhs (Left Hand Side) das Feld bzw. die Variable und #rhs (Right Hand Side) den Ausdruck der zugewiesen wird. Dieser Faktentyp existiert schon im JTransformer, ist aber dort nicht dokumentiert

precedenceT(#id, #parent, #encl, #exp)

stellt eine Klammer im Sourcecode dar.


research/jtransformer/trash/altenversionderdokumentation.txt · Last modified: 2018/05/09 01:59 (external edit)

SEWiki, © 2019