SDA SE Wiki

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

User Tools

Site Tools


Differences

This shows you the differences between two versions of the page.

Link to this comparison view

research:jtransformer:trash:altenversionderdokumentation [2018/05/09 01:59] (current)
Line 1: Line 1:
 +
 +==== 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.
 +  -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