de.dhbwstuttgart.syntaxtree

## Class SourceFile

- java.lang.Object
- - de.dhbwstuttgart.syntaxtree.SyntaxTreeNode
  - - de.dhbwstuttgart.syntaxtree.SourceFile

All Implemented Interfaces:
  IItemWithOffset

    public class SourceFile
    extends SyntaxTreeNode

### Field Summary

Fields
`private java.util.Hashtable<java.lang.String,java.lang.String>` `baseTypeTranslationTable` Table zum Ãbersetzen der nicht implementierten Base-Types: Ãberall im Compiler wird statt bspw. int Integer verwendet d.h. 1+2 liefert ein Integer Deshalb benÃ¶tigen wir hier eine Tabelle, mit der man die von der JRE gelieferten Base-Typen (int,char, etc) und die Objekt- Typen umwandeln kÃ¶nnen
`protected static Logger` `codegenlog`
`private ImportDeclarations` `imports` HOTI 4.5.06 Beinhaltet alle Imports des aktuell geparsten Files in Form einer UsedId
`protected static Logger` `inferencelog`
`Menge<Interface>` `InterfaceVektor`
`Menge<Class>` `KlassenVektor`
`private static boolean` `LOAD_BASIC_ASSUMPTIONS_FROM_JRE`
`private UsedId` `pkgName`
`private static boolean` `READ_BASE_TYPE_SUPERCLASSES_FROM_JRE` Wenn dieses Flag auf false ist, werden fÃ¼r alle Basisklassen (definiert durch die Hashtable baseTypeTranslationTable) KEINE Superklassen geladen.
`private static boolean` `READ_IMPORTED_SUPERCLASSES_FROM_JRE`
`static boolean` `READ_OBJECT_SUPERCLASSES_FROM_JRE`

### Fields inherited from class de.dhbwstuttgart.syntaxtree.SyntaxTreeNode

`parent`

### Constructor Summary

Constructors
Constructor and Description
`SourceFile()` Die SourceFile reprÃ¤sntiert eine zu einem Syntaxbaum eingelesene Java-Datei.
`SourceFile(Menge<Class> classDefinitions)`

### Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
`void` `addElement(AClassOrInterface e)` Fuegt ein neues Element (Interface oder Klasse) hinzu.
`void` `addImports(ImportDeclarations imports)`
`private boolean` `containsString(Menge<UsedId> searchMenge, java.lang.String searchString)`
`private Pair` `createPairFromClassAndSuperclass(Class baseClass, Type superclass, Menge classParaOrg, Menge superclassParaOrg, TypeAssumptions ass)` Erstellt ein Typ-Paar, welches im 1.
`private Type` `createTypeFromJavaGenericType(java.lang.reflect.Type type, java.lang.Class<?> cl, java.util.Hashtable<java.lang.String,GenericTypeVar> jreSpiderRegistry, Class parentClass)`
`Menge<SyntaxTreeNode>` `getChildren()`
`java.util.Iterator<Class>` `getClassIterator()`
`ImportDeclarations` `getImports()`
`java.util.Iterator<Interface>` `getInterfaceIterator()`
`int` `getOffset()`
`UsedId` `getPackageName()` Erzeugt fÃ¯Â¿Â½r jede Klasse einen Menge, in den Referenzen auf die GenericTypeVars dieser Klasse gespeichert werden.
`SyntaxTreeNode` `getParent()`
`TypeAssumptions` `getPublicFieldAssumptions()`
`private Class` `getSuperClassOfJREClass(java.lang.Class<?> x, TypeAssumptions ass)`
`int` `getVariableLength()`
`private boolean` `isBaseType(java.lang.String type)`
`private TypeAssumptions` `makeBasicAssumptions()` Erzeugt die Anfangsinformationen Ã¯Â¿Â½ber bereits bekannte Klassen.
`private TypeAssumptions` `makeBasicAssumptionsFromJRE(Menge<UsedId> imports, boolean withSubtypes)` Erstellt die Assumptions der standardmÃ¤Ãig importierten Packages (java.lang.) sowie der von imports Ã¼bergebenen Klassen zusammen.
`FC_TTO` `makeFC(TypeAssumptions ass)` Erstellt die Finite Closure
`void` `parserPostProcessing(SyntaxTreeNode parent)` Wird nach dem Parsen aufgerufen.
`private void` `removeBasicAssumptions()` LÃ¯Â¿Â½scht die Anfangsinformation wieder aus dem Klassenvektor Author: JÃ¯Â¿Â½rg BÃ¯Â¿Â½uerle
`void` `setFileName(java.lang.String filename)` Deprecated.
`private void` `setImports(ImportDeclarations newImports)`
`void` `setPackageName(UsedId pkgName)`
`Menge<TypeinferenceResultSet>` `typeReconstruction(TypeAssumptions globalAssumptions)` Tyrekonstruktionsalgorithmus: ruft fÃ¯Â¿Â½r jede Klasse den Algorithmus TRProg auf.

### Methods inherited from class de.dhbwstuttgart.syntaxtree.SyntaxTreeNode

`addTypeInsertPoints, equals, getDescription, getGTVDeclarationContext, getMatchingParentNode, getParentClass, seesType`

### Methods inherited from class java.lang.Object

`clone, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Field Detail

#### LOAD_BASIC_ASSUMPTIONS_FROM_JRE

    private static final boolean LOAD_BASIC_ASSUMPTIONS_FROM_JRE

See Also:
  Constant Field Values

#### READ_OBJECT_SUPERCLASSES_FROM_JRE

    public static final boolean READ_OBJECT_SUPERCLASSES_FROM_JRE

See Also:
  Constant Field Values

#### READ_BASE_TYPE_SUPERCLASSES_FROM_JRE

    private static final boolean READ_BASE_TYPE_SUPERCLASSES_FROM_JRE

Wenn dieses Flag auf false ist, werden fÃ¼r alle Basisklassen (definiert durch die Hashtable baseTypeTranslationTable) KEINE Superklassen geladen. D.h. Integer hat bspw. nicht die Superklasse Number sondern OBJECT. Dies verursacht bei den Int-Operationen ein Problem (+,-,*,/,<,>,...)

See Also:
  Constant Field Values

#### READ_IMPORTED_SUPERCLASSES_FROM_JRE

    private static final boolean READ_IMPORTED_SUPERCLASSES_FROM_JRE

See Also:
  Constant Field Values

#### codegenlog

    protected static Logger codegenlog

#### inferencelog

    protected static Logger inferencelog

#### pkgName

    private UsedId pkgName

#### KlassenVektor

    public Menge<Class> KlassenVektor

#### InterfaceVektor

    public Menge<Interface> InterfaceVektor

#### imports

    private ImportDeclarations imports

HOTI 4.5.06 Beinhaltet alle Imports des aktuell geparsten Files in Form einer UsedId

#### baseTypeTranslationTable

    private java.util.Hashtable<java.lang.String,java.lang.String> baseTypeTranslationTable

Table zum Ãbersetzen der nicht implementierten Base-Types: Ãberall im Compiler wird statt bspw. int Integer verwendet d.h. 1+2 liefert ein Integer Deshalb benÃ¶tigen wir hier eine Tabelle, mit der man die von der JRE gelieferten Base-Typen (int,char, etc) und die Objekt- Typen umwandeln kÃ¶nnen

### Constructor Detail

#### SourceFile

    public SourceFile()

Die SourceFile reprÃ¤sntiert eine zu einem Syntaxbaum eingelesene Java-Datei. SourceFile stellt dabei den Wurzelknoten des Syntaxbaumes dar.

#### SourceFile

    public SourceFile(Menge<Class> classDefinitions)

### Method Detail

#### addElement

    public void addElement(AClassOrInterface e)

Fuegt ein neues Element (Interface oder Klasse) hinzu.

Parameters:
  `c` -

#### createPairFromClassAndSuperclass

    private Pair createPairFromClassAndSuperclass(Class baseClass,
                                                  Type superclass,
                                                  Menge classParaOrg,
                                                  Menge superclassParaOrg,
                                                  TypeAssumptions ass)

Erstellt ein Typ-Paar, welches im 1. Durchlauf in die Menge der Finite Closure aufgenommen wird Input: Klassenname, Name der Superklasse, ParameterDerKlasse, Parameter der Superklasse

Returns:

#### makeFC

    public FC_TTO makeFC(TypeAssumptions ass)

Erstellt die Finite Closure

Returns:
  FC_TTO-Object, welches die Finite Closure reprÃ¤sentiert

#### getPublicFieldAssumptions

    public TypeAssumptions getPublicFieldAssumptions()

#### typeReconstruction

    public Menge<TypeinferenceResultSet> typeReconstruction(TypeAssumptions globalAssumptions)
                                                     throws CTypeReconstructionException

Tyrekonstruktionsalgorithmus: ruft fÃ¯Â¿Â½r jede Klasse den Algorithmus TRProg auf. Dessen Ergebnismenge A, die Menge aller Typannahmen, fÃ¯Â¿Â½r eine Klasse dient als Eingabe fÃ¯Â¿Â½r TRProg der nÃ¯Â¿Â½chsten Klasse. Am Ende enthÃ¯Â¿Â½lt A alle mÃ¯Â¿Â½glichen Typkombinationen fÃ¯Â¿Â½r alle Klassen zusammen.
Author: JÃ¯Â¿Â½rg BÃ¯Â¿Â½uerle

Returns:
  Liste aller mÃ¯Â¿Â½glichen Typkombinationen
Throws:
  `CTypeReconstructionException` - Wenn was schief lÃ¯Â¿Â½uft

#### makeBasicAssumptionsFromJRE

    private TypeAssumptions makeBasicAssumptionsFromJRE(Menge<UsedId> imports,
                                                        boolean withSubtypes)

Erstellt die Assumptions der standardmÃ¤Ãig importierten Packages (java.lang.) sowie der von imports Ã¼bergebenen Klassen zusammen.

Parameters:
  `imports` -
  `withSuptypes` - - Gibt an, ob auch die subklassen der Packages den Assumptions angefÃ¼gt werden sollen.
Returns:

#### getSuperClassOfJREClass

    private Class getSuperClassOfJREClass(java.lang.Class<?> x,
                                          TypeAssumptions ass)

#### isBaseType

    private boolean isBaseType(java.lang.String type)

#### containsString

    private boolean containsString(Menge<UsedId> searchMenge,
                                   java.lang.String searchString)

#### createTypeFromJavaGenericType

    private Type createTypeFromJavaGenericType(java.lang.reflect.Type type,
                                               java.lang.Class<?> cl,
                                               java.util.Hashtable<java.lang.String,GenericTypeVar> jreSpiderRegistry,
                                               Class parentClass)

#### makeBasicAssumptions

    private TypeAssumptions makeBasicAssumptions()

Erzeugt die Anfangsinformationen Ã¯Â¿Â½ber bereits bekannte Klassen.
Achtung Workaround: Die RefTypes mÃ¯Â¿Â½ssen spÃ¯Â¿Â½ter noch durch BaseTypes ersetzt werden.
Author: JÃ¯Â¿Â½rg BÃ¯Â¿Â½uerle

Returns:
  A priori Typinformationen
Throws:
  `java.lang.ClassNotFoundException`

#### setImports

    private void setImports(ImportDeclarations newImports)

#### removeBasicAssumptions

    private void removeBasicAssumptions()

LÃ¯Â¿Â½scht die Anfangsinformation wieder aus dem Klassenvektor
Author: JÃ¯Â¿Â½rg BÃ¯Â¿Â½uerle

#### getPackageName

    public UsedId getPackageName()

Erzeugt fÃ¯Â¿Â½r jede Klasse einen Menge, in den Referenzen auf die GenericTypeVars dieser Klasse gespeichert werden. Diese Mengeen werden unter den Klassennamen in der Ergebnisdatenstruktur abgelegt. AuÃ¯Â¿Â½erdem werden alle Klassennamen gespeichert.
Author: JÃ¯Â¿Â½rg BÃ¯Â¿Â½uerle

Parameters:
  `res` - / /*private void addClassNamesAndGenericsToRR(CTypeReconstructionResult res){ Iterator<Class> it = this.getClassIterator(); while(it.hasNext()){ Class cl = it.next(); res.addClassName(cl.get_classname()); Menge<GenericTypeVar> genericsList = new Menge<GenericTypeVar>(); for(int i =0; i<cl.get_ParaList().size(); i++){ Type para = (Type)cl.get_ParaList().elementAt(i); if(para instanceof GenericTypeVar){ genericsList.addElement((GenericTypeVar)para); } } res.addGenericTypeVars(cl.get_classname(), genericsList); } }</dd>

#### setPackageName

    public void setPackageName(UsedId pkgName)

#### addImports

    public void addImports(ImportDeclarations imports)

#### getImports

    public ImportDeclarations getImports()

#### getClassIterator

    public java.util.Iterator<Class> getClassIterator()

#### getInterfaceIterator

    public java.util.Iterator<Interface> getInterfaceIterator()

#### parserPostProcessing

    public void parserPostProcessing(SyntaxTreeNode parent)

Description copied from class: `SyntaxTreeNode`
Wird nach dem Parsen aufgerufen. ErfÃ¼llt folgenden Aufgaben: 1. FÃ¼llt fehlende Typangaben mit TPHs auf. 2. VerknÃ¼pft die Knoten des Syntaxbaums. (setzt Parent) 3. Wechselt RefTypes gegebenenfalls mit GenericTypeVars aus. 4. FÃ¼hrt einen Teil des Syntaxckecks durch.

Overrides:
  `parserPostProcessing` in class `SyntaxTreeNode`

#### getParent

    public SyntaxTreeNode getParent()

Overrides:
  `getParent` in class `SyntaxTreeNode`

#### getChildren

    public Menge<SyntaxTreeNode> getChildren()

Specified by:
  `getChildren` in class `SyntaxTreeNode`

#### setFileName

    @Deprecated
    public void setFileName(java.lang.String filename)

Deprecated.
SourceFile stellt eine geparste Java-Datei dar. Mit dieser Methode wird der Name der eingelesenen Datei gesetzt.

Parameters:
  `filename` - - Der Name der eingelesenen JavaDatei

#### getOffset

    public int getOffset()

#### getVariableLength

    public int getVariableLength()