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
    Modifier and Type | Field and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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 it = this.getClassIterator(); while(it.hasNext()){ Class cl = it.next(); res.addClassName(cl.get_classname()); Menge genericsList = new Menge(); for(int i =0; i

    - #### 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()