modified: src/de/dhbwstuttgart/core/JavaTXCompiler.java

modified:   src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java
Zeilen 606 - 623 eingefuegt, um die parallel berechneten Ergebnisse richtig zu filtern
TODO
- Fuer Variance -1 muss das gleiche gemacht werden
- ab Zeile 550: nextSetasListRest muss nach jedem fork aufruf gefiltert werden.

.gitignore

@@ -23,9 +23,3 @@ bin
 
 #
 manually/
-
-logFiles/**
-!logFiles/.gitkeep
-
-src/main/java/de/dhbwstuttgart/parser/antlr/
-src/main/java/de/dhbwstuttgart/sat/asp/parser/antlr/

README.md

@@ -0,0 +1,19 @@
+
+
+# plugin site erstellen
+* die JAvaTXCOmpiler DAtei in ein plugin umwandeln und deployen.
+* siehe: http://www.vogella.com/tutorials/EclipseJarToPlugin/article.html#convert-jar-files-to-osgi-bundles-with-the-p2-maven-plugin
+* AUsführung:
+	* mvn deploy #erstellt die JAR-Datei und steckt sie in ein lokales Repo (maven-repository)
+	* mvn p2:site
+	* mvn package # hier wird die ZIP-Filf zum Einbinden in Eclipse erstellt
+
+# Einbinden in Eclipse
+* In Eclipse kann die Zip-FIle wie ein Plugin installiert werden
+* Hier tritt FEhler auf. Reflections-Library kann nicht installiert werden. Möglicherweise wird sie auch nicht gebraucht
+* Nach dem installieren de.dhbwstuttagrt.JavaTXcompiler zu den DEpendencies des plugins hinzufügen
+* Anschließend unter "Overview" auf "Updata Classpath" klicken
+
+# Windows
+* JAVA_HOME setzen:
+	* export JAVA_HOME=/c/Program\ Files/Java/jdk1.8.0_102/

doc/Generics/generics.tex

@@ -1,25 +0,0 @@
-\documentclass{article}
-
-\begin{document}
-
-\section{Generics sind notwendig}
-Generics können nicht ignoriert werden.
-Folgender Fall ist Typisierbar:
-
-\begin{program}
-<T> T m1(T x){
-	return m2(x);
-}
-
-m2(x){
-	m1(1);
-	m2("Test");
-	return m1(x);
-}
-\end{program}
-
-Beim weglassen des Generics T wäre es aber nicht mehr möglich.
-Dann erhält jeder Constraint, welcher in Verbindung mit der Methode m1 steht
-den selben TPH.
-
-\end{document}

doc/parser.md

@@ -1,24 +0,0 @@
-# Dateien
-* sämtliche Datein im Ordner de.dhbwstuttgart.parser gehören zum Parser
-* Auch zu beachten: pom.xml
-	* Ein Teil der pom.xml instruiert maven zur Kompilierung der Java8.g4 Datei
-	* VORSICHT! Wird nicht zwangsläufig von der IDE ausgeführt
-	* siehe Kapitel "Grammatik -> Parser"
-
-
-## Unterordner antlr
-* Java8.g4
-	* die eigentliche Java Grammatik
-	* hier wurden Anpassungen vorgenommen, damit sie auch typloses Java annimmt
-* alle anderen Dateien in diesem Ordner sind vom ANTLR-Parsergenerator autogeneriert
-
-## Unterordner SyntaxTreeGenerator
-* SyntaxTreeGenerator
-* TODO
-
-# Grammatik -> Parser
-* Die Antlr-Grammatik (Java8.g4) wandelt 
-* Folgende Stellen sind relevant
-	* TODO
-
-

pom.xml

@@ -1,144 +1,181 @@
+
 <project xmlns="http://maven.apache.org/POM/4.0.0" 
 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
+  	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
-http://maven.apache.org/maven-v4_0_0.xsd">
+	http://maven.apache.org/maven-v4_0_0.xsd">
-	<modelVersion>4.0.0</modelVersion>
+  <modelVersion>4.0.0</modelVersion>
-	<groupId>de.dhbwstuttgart</groupId>
+  <groupId>de.dhbwstuttgart</groupId>
-	<artifactId>JavaTXcompiler</artifactId>
+  <artifactId>JavaTXcompiler</artifactId>
-	<packaging>jar</packaging>
+  <packaging>jar</packaging>
    
-	<version>0.1</version>
+  <version>0.1</version>
-	<name>JavaTXcompiler</name>
+  <name>JavaTXcompiler</name>
-	<url>http://maven.apache.org</url>
+  <url>http://maven.apache.org</url>
-	<dependencies>
+  <dependencies>
-		<dependency>
+    <dependency>
-			<groupId>junit</groupId>
+      <groupId>junit</groupId>
-			<artifactId>junit</artifactId>
+      <artifactId>junit</artifactId>
-			<version>4.11</version>
+      <version>4.0</version>
-			<scope>test</scope>
+      <scope>test</scope>
-		</dependency>
+      </dependency>
-		<dependency>
+      <dependency>
-			<groupId>org.antlr</groupId>
+  	  <groupId>org.antlr</groupId>
-			<artifactId>antlr4</artifactId>
+   	 <artifactId>antlr4</artifactId>
-			<version>4.8-1</version>
+   	 <version>4.7</version>
-		</dependency>
+	</dependency>
-		<dependency>
+<dependency>
-			<groupId>commons-io</groupId>
+    <groupId>commons-io</groupId>
-			<artifactId>commons-io</artifactId>
+    <artifactId>commons-io</artifactId>
-			<version>2.6</version>
+    <version>2.6</version>
-		</dependency>
+</dependency>
-		<dependency>
+<dependency>
-			<groupId>com.google.guava</groupId>
+<groupId>com.google.guava</groupId>
-			<artifactId>guava</artifactId>
+    <artifactId>guava</artifactId>
-			<version>22.0</version>
+    <version>22.0</version>
-		</dependency>
+</dependency>
-		<dependency>
+<dependency>
-			<groupId>org.reflections</groupId>
+    <groupId>org.reflections</groupId>
-			<artifactId>reflections</artifactId>
+    <artifactId>reflections</artifactId>
-			<version>0.9.11</version>
+    <version>0.9.11</version>
-		</dependency>
+</dependency>
-		<!-- https://mvnrepository.com/artifact/org.ow2.asm/asm -->
+<dependency>
-		<dependency>
+    <groupId>org.ow2.asm</groupId>
-			<groupId>org.ow2.asm</groupId>
+    <artifactId>asm-all</artifactId>
-			<artifactId>asm</artifactId>
+    <version>[4.0.0,)</version>
-			<version>7.0</version>
+</dependency>
-		</dependency>
+<!--
-		<!-- <dependency> <groupId>org.ow2.asm</groupId> <artifactId>asm-all</artifactId> 
+<dependency>
-			<version>[4.0.0,)</version> </dependency> -->
+    <groupId>org.bitbucket.mstrobel</groupId>
-		<!-- <dependency> <groupId>org.bitbucket.mstrobel</groupId> <artifactId>procyon-reflection</artifactId> 
+    <artifactId>procyon-reflection</artifactId>
-			<version>[0.5.32,)</version> </dependency> -->
+    <version>[0.5.32,)</version>
-	</dependencies>
+</dependency> -->
+  </dependencies>
 
-	<build>
+  <build>
-		<directory>target</directory>
+    <directory>target</directory>
-		<outputDirectory>target/classes</outputDirectory>
+    <outputDirectory>target/classes</outputDirectory>
-		<finalName>${project.artifactId}-${project.version}</finalName>
+    <finalName>${project.artifactId}-${project.version}</finalName>
-		<testOutputDirectory>target/test-classes</testOutputDirectory>
+    <testOutputDirectory>target/test-classes</testOutputDirectory>
-		<plugins>
+    <sourceDirectory>src/</sourceDirectory>
-			<plugin>
+    <testSourceDirectory>test/</testSourceDirectory>
-				<groupId>org.apache.maven.plugins</groupId>
+    <plugins>
-				<artifactId>maven-surefire-plugin</artifactId>
+      <plugin>
-				<version>3.0.0-M3</version>
+        <groupId>org.antlr</groupId>
-				<configuration>
+        <artifactId>antlr4-maven-plugin</artifactId>
-					<skipTests>true</skipTests>
+        <version>4.7</version>
-				</configuration>
+        <executions>
-			</plugin>
+          <execution>
-			<!-- plugin>
+            <id>antlr</id>
-		        <groupId>org.apache.maven.plugins</groupId>
+            <goals>
-		        <artifactId>maven-compiler-plugin</artifactId>
+		    <goal>antlr4</goal>
-		        <version>3.8.1</version>
+	    </goals>
-		        <configuration>
+	    <configuration>
-		          <verbose>true</verbose>
+		    <sourceDirectory>src/de/dhbwstuttgart/parser/antlr/</sourceDirectory>
-		          <fork>true</fork>
+		    <outputDirectory>src/de/dhbwstuttgart/parser/antlr/</outputDirectory>
-		          <executable>/home/michael/programs/jdk/jdk8u232-b09/bin/javac</executable>
+		    <arguments> <argument>-package</argument> <argument>de.dhbwstuttgart.parser.antlr</argument> </arguments>
-		          <compilerVersion>1.8</compilerVersion>
+	    </configuration>
-		          <source>1.8</source>
+	    </execution>
-		          <target>1.8</target>
+	    <execution>
-		        </configuration>
+            <id>aspParser</id>
-		    </plugin -->	
+            <goals>
-			<plugin>
+		    <goal>antlr4</goal>
-				<groupId>org.antlr</groupId>
+	    </goals>
-				<artifactId>antlr4-maven-plugin</artifactId>
+	    <configuration>
-				<version>4.8-1</version>
+		    <sourceDirectory>src/de/dhbwstuttgart/sat/asp/parser/antlr/</sourceDirectory>
-				<executions>
+		    <outputDirectory>src/de/dhbwstuttgart/sat/asp/parser/antlr/</outputDirectory>
-					<execution>
+		    <arguments>
-						<id>antlr</id>
+			    <argument>-package</argument>
-						<goals>
+			   <argument>de.dhbwstuttgart.sat.asp.parser.antlr</argument>
-							<goal>antlr4</goal>
+	  	    </arguments>
-						</goals>
+	    </configuration>
-						<configuration>
+          </execution>
-							<sourceDirectory>src/main/antlr4/java8</sourceDirectory>
+
-							<outputDirectory>${project.basedir}/src/main/java/de/dhbwstuttgart/parser/antlr</outputDirectory>
+        </executions>
-							<arguments>
+</plugin>
-								<argument>-package</argument>
+ <plugin>
-								<argument>de.dhbwstuttgart.parser.antlr</argument>
+        <artifactId>maven-assembly-plugin</artifactId>
-							</arguments>
+        <executions>
-						</configuration>
+          <execution>
-					</execution>
+            <phase>package</phase>
-				</executions>
+            <goals>
-			</plugin>
+              <goal>single</goal>
-			<plugin>
+            </goals>
-				<artifactId>maven-assembly-plugin</artifactId>
+          </execution>
-				<executions>
+        </executions>
-					<execution>
+        <configuration>
-						<phase>package</phase>
+          <descriptorRefs>
-						<goals>
+            <descriptorRef>jar-with-dependencies</descriptorRef>
-							<goal>single</goal>
+          </descriptorRefs>
-						</goals>
+        </configuration>
-					</execution>
+      </plugin>
-				</executions>
+<plugin>
-				<configuration>
+    <groupId>org.reficio</groupId>
-					<archive>
+    <artifactId>p2-maven-plugin</artifactId>
-						<manifest>
+    <version>1.1.2-SNAPSHOT</version>
-							<mainClass>de.dhbwstuttgart.core.ConsoleInterface</mainClass>
+    <executions>
-						</manifest>
+     <execution>
-					</archive>
+      <id>default-cli</id>
-					<descriptorRefs>
+      <configuration>
-						<descriptorRef>jar-with-dependencies</descriptorRef>
+       <artifacts>
-					</descriptorRefs>
+        <!-- specify your depencies here -->
-				</configuration>
+	<!-- groupId:artifactId:version -->
-			</plugin>
+        <artifact>
-		</plugins>
+		<id>de.dhbwstuttgart:JavaTXcompiler:0.1</id>
-	</build>
+        </artifact>
-	<repositories>
+		<artifact><id>org.reflections:reflections:0.9.11</id></artifact>
-		<repository>
+		<artifact><id>com.google.guava:guava:22.0</id></artifact>
-			<id>maven-repository</id>
+		<artifact><id>javax.annotation:javax.annotation-api:1.3.1</id></artifact>
-			<url>file:///${project.basedir}/target</url>
+		<artifact><id>org.glassfish:javax.annotation:3.1.1</id></artifact>
-		</repository>
+       </artifacts>
-	</repositories>
+      </configuration>
-	<properties>
+     </execution>
-	    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </executions>
-		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+   </plugin>
-		<maven.compiler.source>1.8</maven.compiler.source>
+   <plugin>
-		<maven.compiler.target>1.8</maven.compiler.target>
+    <groupId>org.eclipse.tycho</groupId>
-		<tycho.version>0.23.0</tycho.version>
+    <artifactId>tycho-p2-repository-plugin</artifactId>
-		<mainClass>de.dhbwstuttgart.core.ConsoleInterface</mainClass>
+    <version>${tycho.version}</version>
-	</properties>
+    <executions>
-	<distributionManagement>
+     <execution>
-		<repository>
+      <phase>package</phase>
-			<id>maven-repository</id>
+      <goals>
-			<name>MyCo Internal Repository</name>
+       <goal>archive-repository</goal>
-			<url>file:///${project.basedir}/maven-repository/</url>
+      </goals>
-		</repository>
+     </execution>
-	</distributionManagement>
+    </executions>
+   </plugin>
+        <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-compiler-plugin</artifactId>
+            <configuration>
+                <source>9</source>
+                <target>9</target>
+            </configuration>
+        </plugin>
+    </plugins>
+       </build>
+        <pluginRepositories>
+  <pluginRepository>
+   <id>reficio</id>
+   <url>http://repo.reficio.org/maven/</url>
+  </pluginRepository>
+ </pluginRepositories>
+ <repositories>
+	 <repository>
+        <id>maven-repository</id>
+	<url>file:///${project.basedir}/target</url>
+</repository>
+</repositories>
+   <properties>
+    <maven.compiler.source>1.8</maven.compiler.source>
+    <maven.compiler.target>1.8</maven.compiler.target>
+    <tycho.version>0.23.0</tycho.version>
+  </properties>
+  <distributionManagement>
+    <repository>
+	    <id>maven-repository</id>
+      <name>MyCo Internal Repository</name>
+      <url>file:///${project.basedir}/maven-repository/</url>
+    </repository>
+  </distributionManagement>
 </project>

src/build_compiler.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+# A basic script to compile the necessary packages and their subpackages to work with the parser.
+# Messages are logged to stderr.
+>&2 echo "Building de.dhbwstuttgart.typecheck..."
+javac -d ../bin ./de/dhbwstuttgart/typecheck/*.java
+>&2 echo "Building de.dhbwstuttgart.syntaxtree..."
+javac -d ../bin ./de/dhbwstuttgart/syntaxtree/*.java
+>&2 echo "Building de.dhbwstuttgart.syntaxtree.factory..."
+javac -d ../bin ./de/dhbwstuttgart/syntaxtree/factory/*.java
+>&2 echo "Building de.dhbwstuttgart.syntaxtree.operator..."
+javac -d ../bin ./de/dhbwstuttgart/syntaxtree/operator/*.java
+>&2 echo "Building de.dhbwstuttgart.syntaxtree.statement..."
+javac -d ../bin ./de/dhbwstuttgart/syntaxtree/statement/*.java
+>&2 echo "Building de.dhbwstuttgart.syntaxtree.statement.literal..."
+javac -d ../bin ./de/dhbwstuttgart/syntaxtree/statement/literal/*.java
+>&2 echo "Building de.dhbwstuttgart.syntaxtree.type..."
+javac -d ../bin ./de/dhbwstuttgart/syntaxtree/type/*.java
+>&2 echo "Building de.dhbwstuttgart.parser..."
+javac -d ../bin ./de/dhbwstuttgart/parser/*.java
+>&2 echo "Building de.dhbwstuttgart.parser.SyntaxTreeGenerator..."
+javac -d ../bin ./de/dhbwstuttgart/parser/SyntaxTreeGenerator/*.java
+>&2 echo "Building de.dhbwstuttgart.parser.antlr..."
+javac -d ../bin ./de/dhbwstuttgart/parser/antlr/*.java
+echo "Done. Now its your turn to debug:)."

src/de/dhbwstuttgart/bytecode/ArgumentVisitor.java

@@ -61,7 +61,7 @@ public class ArgumentVisitor implements StatementVisitor {
 		assign.accept(bytecodeGenMethod);
 		
 		if(argListMethCall.get(0))
-			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolver().getResolvedType(assign.getType()));
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(assign.getType()));
 		argListMethCall.remove(0);
 	}
 
@@ -69,11 +69,8 @@ public class ArgumentVisitor implements StatementVisitor {
 	public void visit(BinaryExpr binary) {
 		binary.accept(bytecodeGenMethod);
 		
-		if(argListMethCall.get(0)) {
+		if(argListMethCall.get(0))
-			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolver().getResolvedType(binary.getType()));
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(binary.getType()));
-		} else {
-			bytecodeGenMethod.doBoxing(bytecodeGenMethod.getResolver().getResolvedType(binary.getType()));
-		}
 		argListMethCall.remove(0);
 	}
 
@@ -88,7 +85,7 @@ public class ArgumentVisitor implements StatementVisitor {
 		castExpr.accept(bytecodeGenMethod);
 		
 		if(argListMethCall.get(0))
-			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolver().getResolvedType(castExpr.getType()));
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(castExpr.getType()));
 		argListMethCall.remove(0);
 	}
 
@@ -103,7 +100,7 @@ public class ArgumentVisitor implements StatementVisitor {
 		fieldVar.accept(bytecodeGenMethod);
 		
 		if(argListMethCall.get(0))
-			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolver().getResolvedType(fieldVar.getType()));
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(fieldVar.getType()));
 		argListMethCall.remove(0);
 	}
 
@@ -124,7 +121,7 @@ public class ArgumentVisitor implements StatementVisitor {
 		instanceOf.accept(bytecodeGenMethod);
 		
 		if(argListMethCall.get(0))
-			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolver().getResolvedType(instanceOf.getType()));
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(instanceOf.getType()));
 		argListMethCall.remove(0);
 	}
 
@@ -133,7 +130,7 @@ public class ArgumentVisitor implements StatementVisitor {
 		localVar.accept(bytecodeGenMethod);
 		if(!bytecodeGenMethod.isBinaryExp) {
 			if(argListMethCall.get(0))
-				bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolver().getResolvedType(localVar.getType()));
+				bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(localVar.getType()));
 		}
 		argListMethCall.remove(0);
 	}
@@ -149,7 +146,7 @@ public class ArgumentVisitor implements StatementVisitor {
 		methodCall.accept(bytecodeGenMethod);
 		
 		if(argListMethCall.get(0))
-			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolver().getResolvedType(methodCall.getType()));
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(methodCall.getType()));
 		argListMethCall.remove(0);
 	}
 
@@ -158,7 +155,7 @@ public class ArgumentVisitor implements StatementVisitor {
 		methodCall.accept(bytecodeGenMethod);
 		
 		if(argListMethCall.get(0))
-			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolver().getResolvedType(methodCall.getType()));
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(methodCall.getType()));
 		argListMethCall.remove(0);
 	}
 
@@ -197,7 +194,7 @@ public class ArgumentVisitor implements StatementVisitor {
 		aThis.accept(bytecodeGenMethod);
 		
 		if(argListMethCall.get(0))
-			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolver().getResolvedType(aThis.getType()));
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(aThis.getType()));
 		argListMethCall.remove(0);
 	}
 
@@ -242,7 +239,7 @@ public class ArgumentVisitor implements StatementVisitor {
 		unaryExpr.accept(bytecodeGenMethod);
 		
 		if(argListMethCall.get(0))
-			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolver().getResolvedType(unaryExpr.getType()));
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(unaryExpr.getType()));
 		argListMethCall.remove(0);
 	}
 
@@ -251,7 +248,7 @@ public class ArgumentVisitor implements StatementVisitor {
 		literal.accept(bytecodeGenMethod);
 		
 		if(argListMethCall.get(0))
-			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolver().getResolvedType(literal.getType()));
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(literal.getType()));
 		argListMethCall.remove(0);
 	}
 

src/de/dhbwstuttgart/bytecode/BytecodeGen.java

@@ -0,0 +1,659 @@
+package de.dhbwstuttgart.bytecode;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+
+import de.dhbwstuttgart.exceptions.NotImplementedException;
+import de.dhbwstuttgart.syntaxtree.statement.*;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.FieldVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+
+import de.dhbwstuttgart.bytecode.descriptor.DescriptorToString;
+import de.dhbwstuttgart.bytecode.descriptor.TypeToDescriptor;
+import de.dhbwstuttgart.bytecode.signature.Signature;
+import de.dhbwstuttgart.bytecode.signature.TypeToSignature;
+import de.dhbwstuttgart.bytecode.signature.TypeToString;
+import de.dhbwstuttgart.bytecode.utilities.MethodAndTPH;
+import de.dhbwstuttgart.bytecode.utilities.NormalConstructor;
+import de.dhbwstuttgart.bytecode.utilities.NormalMethod;
+import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
+import de.dhbwstuttgart.syntaxtree.*;
+import de.dhbwstuttgart.syntaxtree.statement.Literal;
+import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
+import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.typeinference.result.GenericInsertPair;
+import de.dhbwstuttgart.typeinference.result.ResolvedType;
+import de.dhbwstuttgart.typeinference.result.ResultPair;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+public class BytecodeGen implements ASTVisitor {
+	
+	ClassWriter cw =new ClassWriter(ClassWriter.COMPUTE_FRAMES|ClassWriter.COMPUTE_MAXS);
+	
+	String type;
+
+	String className;
+	private boolean isInterface;
+	private List<ResultSet> listOfResultSets;
+	private ResultSet resultSet;
+	private SourceFile sf;
+	private String path;
+	
+	private int indexOfFirstParam = 0;
+	
+	private String superClass;
+	
+	// stores parameter, local vars and the next index on the local variable table, which use for aload_i, astore_i,...
+	HashMap<String, Integer> paramsAndLocals = new HashMap<>();
+	// stores generics and their bounds of class
+	HashMap<String, String> genericsAndBounds = new HashMap<>();
+	// stores generics and their bounds of method
+	HashMap<String, String> genericsAndBoundsMethod = new HashMap<>();
+	
+	private final TPHExtractor tphExtractor = new TPHExtractor();
+	private final ArrayList<GenericInsertPair> commonPairs = new ArrayList<>();
+	
+	HashMap<String,RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes = new HashMap<>();
+	byte[] bytecode;
+	HashMap<String,byte[]> classFiles;
+	
+	ArrayList<String> methodNameAndParamsT = new ArrayList<>();
+	
+	public BytecodeGen(HashMap<String,byte[]> classFiles, List<ResultSet> listOfResultSets,SourceFile sf ,String path) {
+		this.classFiles = classFiles;
+		this.listOfResultSets = listOfResultSets;
+		this.sf = sf;
+		this.path = path;
+	}
+	
+	@Override
+	public void visit(SourceFile sourceFile) {
+		for(ClassOrInterface cl : sourceFile.getClasses()) {
+			System.out.println("in Class: " + cl.getClassName().toString());
+			BytecodeGen classGen = new BytecodeGen(classFiles, listOfResultSets, sf, path);
+			cl.accept(classGen);
+			classGen.writeClass(cl.getClassName().toString());
+		}
+	}
+	
+	/**
+	 * Associates the bytecode of the class that was build with the classWriter {@link #cw}
+	 * with the class name in the map {@link #classFiles}
+	 * 
+	 * @param name name of the class with which the the bytecode is to be associated
+	 */
+	private void writeClass(String name) {
+		bytecode = cw.toByteArray();
+		classFiles.put(name, bytecode);
+		
+	}
+	
+	public HashMap<String,byte[]> getClassFiles() {
+		return classFiles;
+	}
+	
+	
+	@Override
+	public void visit(ClassOrInterface classOrInterface) {
+		
+		className = classOrInterface.getClassName().toString();
+		
+		cw.visitSource(className +".jav", null);
+		
+		isInterface = (classOrInterface.getModifiers()&512)==512;
+
+		int acc = isInterface?classOrInterface.getModifiers()+Opcodes.ACC_ABSTRACT:classOrInterface.getModifiers()+Opcodes.ACC_SUPER;
+		
+		
+//		resultSet = listOfResultSets.get(0);
+		boolean isConsWithNoParamsVisited = false;
+		boolean isVisited = false;
+		for(ResultSet rs : listOfResultSets) {
+			superClass = classOrInterface.getSuperClass().acceptTV(new TypeToDescriptor());
+			resultSet = rs;
+			// Nur einmal ausführen!!
+			if(!isVisited) {
+				classOrInterface.accept(tphExtractor);
+
+				getCommonTPHS(tphExtractor);
+
+				String sig = null;
+				/* if class has generics then creates signature
+				 * Signature looks like:
+				 * <E:Ljava/...>Superclass 
+				 */
+				if(classOrInterface.getGenerics().iterator().hasNext() || !commonPairs.isEmpty() || 
+						classOrInterface.getSuperClass().acceptTV(new TypeToSignature()).contains("<")) {
+					Signature signature = new Signature(classOrInterface, genericsAndBounds,commonPairs);
+					sig = signature.toString();
+					System.out.println("Signature: => " + sig);
+				}
+				
+				cw.visit(Opcodes.V1_8, acc, classOrInterface.getClassName().toString()
+						, sig, classOrInterface.getSuperClass().acceptTV(new TypeToDescriptor()), null);
+				
+				isVisited = true;
+			}
+			
+			for(Field f : classOrInterface.getFieldDecl()) {
+				f.accept(this);
+			}
+			
+			for(Constructor c : classOrInterface.getConstructors()) {
+				if(!isConsWithNoParamsVisited)
+					c.accept(this);
+				if(!c.getParameterList().iterator().hasNext())
+					isConsWithNoParamsVisited = true;
+			}
+			
+			for(Method m : classOrInterface.getMethods()) {
+				m.accept(this);
+			}
+		
+		}
+		
+	}
+
+	private void getCommonTPHS(TPHExtractor tphExtractor) {
+		// Gemeinsame TPHs
+		ArrayList<TypePlaceholder> cTPHs = new ArrayList<>();
+		// Alle TPHs der Felder speichern
+		for(TypePlaceholder tph : tphExtractor.allTPHS.keySet()) {
+			if(!tphExtractor.allTPHS.get(tph))
+				cTPHs.add(tph);
+		}
+	}
+
+	@Override
+	public void visit(Constructor field) {
+		field.getParameterList().accept(this);
+		
+		String desc = null;
+		boolean hasGen = false;
+		
+		for(String paramName : methodParamsAndTypes.keySet()) {
+			String typeOfParam = methodParamsAndTypes.get(paramName).acceptTV(new TypeToSignature());
+			if(genericsAndBounds.containsKey(typeOfParam) ||typeOfParam.substring(0, 4).equals("TPH ")
+					|| typeOfParam.contains("<")) {
+				hasGen = true;
+				break;
+			}
+		}
+		String sig = null;
+		if(hasGen) {
+			ArrayList<GenericInsertPair> pairs = simplifyPairs(field.name,tphExtractor.allPairs);
+			Signature signature = new Signature(field, genericsAndBounds,methodParamsAndTypes,resultSet,pairs);
+			sig = signature.toString();
+		}
+		NormalConstructor constructor = new NormalConstructor(field,genericsAndBounds,hasGen);
+		desc = constructor.accept(new DescriptorToString(resultSet));
+		MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", desc, sig, null);
+		mv.visitCode();		
+		BytecodeGenMethod gen = new BytecodeGenMethod(className,superClass,resultSet,field, mv,paramsAndLocals,cw,
+				genericsAndBoundsMethod,genericsAndBounds,isInterface,classFiles, sf,path);
+		if(!field.getParameterList().iterator().hasNext()) {
+			mv.visitInsn(Opcodes.RETURN);
+		}
+		mv.visitMaxs(0, 0);
+		mv.visitEnd();
+	}
+	
+	@Override
+	public void visit(Method method) {
+		// TODO: check if the method is static => if static then the first param will be stored in pos 0
+		// else it will be stored in pos 1 and this will be stored in pos 0
+		String retType = resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
+		String methParamTypes = retType+method.name+"%%";
+		method.getParameterList().accept(this);
+
+		Iterator<FormalParameter> itr = method.getParameterList().iterator();
+		while(itr.hasNext()) {
+			FormalParameter fp = itr.next();
+			methParamTypes += resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+";";
+		}
+		
+		if(methodNameAndParamsT.contains(methParamTypes)) {
+			return;
+		}
+		methodNameAndParamsT.add(methParamTypes);
+		System.out.println("Method: "+method.name +" , paramsType: "+methParamTypes);
+		String methDesc = null;
+		
+		// Method getModifiers() ?
+		int acc = isInterface?Opcodes.ACC_ABSTRACT:method.modifier;
+		System.out.println(acc);
+		
+		/*Prüfe, ob die Rückgabe-Type der Methode eine Type-Variable ist*/
+		boolean hasGenInParameterList = genericsAndBounds.containsKey(retType) || retType.subSequence(0, 4).equals("TPH ") ||
+										resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToSignature()).contains("<");
+		/*Wenn die Rückgabe-Type eine Typ-variable ist, erzeuge direkt die Signature, wenn nicht,
+		 * prüfe, ob einer der Parameter Typ-Variable als Typ hat*/
+		if(!hasGenInParameterList) {
+			for(String paramName : methodParamsAndTypes.keySet()) {
+				String typeOfParam = methodParamsAndTypes.get(paramName).acceptTV(new TypeToDescriptor());
+				String sigOfParam = methodParamsAndTypes.get(paramName).acceptTV(new TypeToSignature());
+				if(genericsAndBounds.containsKey(typeOfParam)||typeOfParam.substring(0, 4).equals("TPH ")||sigOfParam.contains("<")) {
+					hasGenInParameterList = true;
+					break;
+				}
+			}
+		}
+		
+		//TODO: Test if the return-type or any of the parameter is a parameterized type. (VP)
+		//then create the descriptor with the new syntax.
+		
+		String sig = null;
+		/* method.getGenerics: <....> RT method(..) 
+		 * */
+		boolean hasGen = method.getGenerics().iterator().hasNext() || hasGenInParameterList;
+		/* if method has generics or return type is TPH, create signature */
+		// zwite operand muss weggelassen werden
+		if(hasGen||resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToString()).equals("TPH")) {
+			ArrayList<GenericInsertPair> pairs = simplifyPairs(method.name,tphExtractor.allPairs);
+			System.out.println(method.name + " => Simplified Pairs: ");
+			pairs.forEach(p->System.out.println(p.TA1.getName() + " -> "+p.TA2.getName()));
+			Signature signature = new Signature(method, genericsAndBoundsMethod, genericsAndBounds,methodParamsAndTypes,resultSet, pairs);
+			sig = signature.toString();
+		}
+		System.out.println(method.getName()+" ==> "+sig);
+		NormalMethod meth = new NormalMethod(method,genericsAndBounds,genericsAndBoundsMethod,hasGen);
+		methDesc = meth.accept(new DescriptorToString(resultSet));
+		
+//		System.out.println(methDesc);
+		MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC+acc, method.getName(), methDesc, sig, null);
+
+		mv.visitCode();		
+		BytecodeGenMethod gen = new BytecodeGenMethod(className,superClass,resultSet,method, mv,paramsAndLocals,cw,
+				genericsAndBoundsMethod,genericsAndBounds,isInterface,classFiles, sf,path);
+		
+		mv.visitMaxs(0, 0);
+		mv.visitEnd();
+	}
+	
+	private ArrayList<GenericInsertPair> simplifyPairs(String methodName, ArrayList<GenericInsertPair> allPairs) {
+		allPairs.forEach(p->System.out.print(p.TA1 + " < "+ p.TA2+ " ; "));
+		
+		if(allPairs.size() < 2)
+			return allPairs;
+		
+		ArrayList<GenericInsertPair> simplifiedPairs = new ArrayList<>();
+		
+		MethodAndTPH method;
+		ArrayList<TypePlaceholder> methodTphs = new ArrayList<>();
+		ArrayList<GenericInsertPair> methodPairs = new ArrayList<>();
+		for(MethodAndTPH m : tphExtractor.ListOfMethodsAndTph) {
+			if(m.getName().equals(methodName)) {
+				methodTphs = m.getTphs();
+				methodPairs = m.getPairs();
+				break;
+			}
+		}
+
+		HashMap<TypePlaceholder, TypePlaceholder> subAndSuperTph = new HashMap<>();
+		for(GenericInsertPair p : allPairs) {
+			// Tph2.jav
+			if(subAndSuperTph.containsKey(p.TA1)) {
+				if(methodTphs.contains(subAndSuperTph.get(p.TA1)))
+					continue;
+			}
+			subAndSuperTph.put(p.TA1, p.TA2);
+		}
+		int numOfVisitedPairs = 0;
+		for(TypePlaceholder subTph: subAndSuperTph.keySet()) {
+			
+			if(numOfVisitedPairs>=subAndSuperTph.size())
+				break;
+			
+			if(!methodTphs.contains(subTph))
+				continue;
+			
+			HashMap<Integer, TypePlaceholder> tphsInRel= new HashMap<>();
+			
+			tphsInRel.put(tphsInRel.size(), subTph);
+			TypePlaceholder superTph = subAndSuperTph.get(subTph);
+			tphsInRel.put(tphsInRel.size(), superTph);
+			
+			numOfVisitedPairs++;
+			
+			while(subAndSuperTph.containsKey(superTph)) {
+				superTph = subAndSuperTph.get(superTph);
+				tphsInRel.put(tphsInRel.size(), superTph);
+				numOfVisitedPairs++;
+			}
+			
+			// Subtype
+			TypePlaceholder subTphRes = tphsInRel.get(0);
+			// Die größte Supertype
+			TypePlaceholder superTphRes = tphsInRel.get(tphsInRel.size()-1);
+			
+			while(subAndSuperTph.containsValue(subTphRes)) {
+				for(TypePlaceholder tph : subAndSuperTph.keySet()) {
+					if(methodTphs.contains(tph) && subAndSuperTph.get(tph).equals(subTphRes)) {
+						subTphRes = tph;
+						break;
+					}
+				}
+				if(subTphRes.equals(tphsInRel.get(0))) {
+					break;
+				}
+				tphsInRel.put(0, subTphRes);
+				numOfVisitedPairs++;
+			}
+			
+			subTphRes = tphsInRel.get(0);
+			
+			int i = 2;
+			while(!methodTphs.contains(superTphRes) && (tphsInRel.size()-i) >0) {
+				superTphRes = tphsInRel.get(tphsInRel.size()-i);
+				i++;
+			}
+			// teste noch den Fall X < Y und Y nicht in TPHS der Methode
+			// 		 Dann hat man nach der While-Schleife X < Y
+			//		 Y muss durch Object ersetzt.
+			
+			// Zweite Operand für die Fälle wie in Lambda.jav (Paramtrisierte Typen) 
+			if(methodTphs.contains(superTphRes) || !tphExtractor.allTPHS.containsKey(superTphRes)) {
+				GenericInsertPair sPair = new GenericInsertPair(subTphRes, superTphRes);
+				simplifiedPairs.add(sPair);
+			}
+		}
+		return simplifiedPairs;
+	}
+
+	@Override
+	public void visit(ParameterList formalParameters) {
+		paramsAndLocals = new HashMap<>();
+		methodParamsAndTypes = new HashMap<>();
+		Iterator<FormalParameter> itr = formalParameters.iterator();
+		int i = 1;
+		while(itr.hasNext()) {
+			FormalParameter fp = itr.next();
+			paramsAndLocals.put(fp.getName(), i);
+			methodParamsAndTypes.put(fp.getName(), resultSet.resolveType(fp.getType()).resolvedType);
+			fp.accept(this);
+			i++;
+		}
+	}
+	
+	@Override
+	public void visit(FormalParameter formalParameter) {
+		formalParameter.getType().accept(this);
+	}
+	
+	@Override
+	public void visit(RefType refType) {
+		type = "L"+refType.toString()+";";
+	}
+
+	@Override
+	public void visit(SuperWildcardType superWildcardType) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(TypePlaceholder typePlaceholder) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(ExtendsWildcardType extendsWildcardType) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(GenericRefType genericRefType) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	// ??
+	@Override
+	public void visit(FieldVar fieldVar) {
+//		cw.newField(fieldVar.receiver.toString(), fieldVar.fieldVarName.toString(), fieldVar.getType().toString());
+		FieldVisitor fv = cw.visitField(Opcodes.ACC_PRIVATE, fieldVar.fieldVarName, "L"+fieldVar.getType()+";", null, null);
+		fv.visitEnd();
+	}
+	
+	// access flages?? modifiers
+	@Override
+	public void visit(Field field) {
+		FieldVisitor fv = cw.visitField(Opcodes.ACC_PRIVATE, field.getName(), "L"+field.getType().toString().replace(".", "/")+";", null, null);
+		fv.visitEnd();
+	}
+
+	@Override
+	public void visit(LambdaExpression lambdaExpression) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(Assign assign) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(BinaryExpr binary) {
+
+	}
+
+	@Override
+	public void visit(Block block) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(CastExpr castExpr) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(EmptyStmt emptyStmt) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(ForStmt forStmt) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(IfStmt ifStmt) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(InstanceOf instanceOf) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(LocalVar localVar) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(LocalVarDecl localVarDecl) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(MethodCall methodCall) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(NewClass methodCall) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(NewArray newArray) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(Return aReturn) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(ReturnVoid aReturn) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(StaticClassName staticClassName) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(Super aSuper) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(This aThis) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(WhileStmt whileStmt) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(DoStmt whileStmt) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	// ???
+	@Override
+	public void visit(Literal literal) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(ArgumentList argumentList) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(GenericTypeVar genericTypeVar) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(GenericDeclarationList genericTypeVars) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(AssignToField assignLeftSide) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(AssignToLocal assignLeftSide) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(SuperCall superCall) {
+		
+	}
+
+	@Override
+	public void visit(ExpressionReceiver expressionReceiver) {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void visit(UnaryExpr unaryExpr) {
+		throw new NotImplementedException();
+	}
+	
+	private class TPHExtractor extends AbstractASTWalker{
+		// Alle TPHs der Felder werden iKopf der Klasse definiert
+		// alle TPHs der Klasse: (TPH, is in Method?)
+		final HashMap<TypePlaceholder,Boolean> allTPHS = new HashMap<>();
+		MethodAndTPH methodAndTph;
+		Boolean inMethod = false;
+		final ArrayList<MethodAndTPH> ListOfMethodsAndTph = new ArrayList<>();
+		final ArrayList<GenericInsertPair> allPairs = new ArrayList<>();
+		
+		@Override
+		public void visit(TypePlaceholder tph) {
+			if(resultSet.resolveType(tph).resolvedType instanceof TypePlaceholder) {
+				TypePlaceholder resolvedTPH = (TypePlaceholder) resultSet.resolveType(tph).resolvedType;
+				if(inMethod)
+					methodAndTph.getTphs().add(resolvedTPH);
+				
+				allTPHS.put(resolvedTPH,inMethod);
+				resultSet.resolveType(tph).additionalGenerics.forEach(ag ->{
+					if(ag.contains(resolvedTPH)&&ag.TA1.equals(resolvedTPH)&&!contains(allPairs,ag)) {
+						if(inMethod)
+							methodAndTph.getPairs().add(ag);
+						allPairs.add(ag);
+					}
+				});
+			}
+		}
+		private boolean contains(ArrayList<GenericInsertPair> pairs, GenericInsertPair genPair) {
+			for(int i=0; i<pairs.size();++i) {
+				GenericInsertPair p = pairs.get(i);
+				if(p.TA1.equals(genPair.TA1) && p.TA2.equals(genPair.TA2))
+					return true;
+			}
+			return false;
+		}
+		@Override
+		public void visit(Method method) {
+			inMethod = true;
+			methodAndTph = new MethodAndTPH(method.name);
+			super.visit(method);
+			inMethod = false;
+			ListOfMethodsAndTph.add(methodAndTph);
+		}
+		
+	}
+
+}

src/de/dhbwstuttgart/bytecode/descriptor/DescriptorToString.java

@@ -1,29 +1,30 @@
 package de.dhbwstuttgart.bytecode.descriptor;
 
-import java.util.HashMap;
 import java.util.Iterator;
 
-import de.dhbwstuttgart.bytecode.utilities.*;
-import de.dhbwstuttgart.syntaxtree.statement.ArgumentList;
 import org.objectweb.asm.Type;
 
+import de.dhbwstuttgart.bytecode.signature.TypeToSignature;
+import de.dhbwstuttgart.bytecode.utilities.Lambda;
+import de.dhbwstuttgart.bytecode.utilities.MethodFromMethodCall;
+import de.dhbwstuttgart.bytecode.utilities.NormalConstructor;
+import de.dhbwstuttgart.bytecode.utilities.NormalMethod;
+import de.dhbwstuttgart.bytecode.utilities.SamMethod;
 import de.dhbwstuttgart.syntaxtree.FormalParameter;
 import de.dhbwstuttgart.syntaxtree.statement.Expression;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
 
-public class DescriptorToString implements DescriptorVisitor, CONSTANTS {
+public class DescriptorToString implements DescriptorVisitor{
 	ResultSet resultSet;
 	
-	public DescriptorToString() {
-	}
-
 	public DescriptorToString(ResultSet resultSet) {
 		this.resultSet = resultSet;
 	}
 	
 	private String addReturnType(String desc, RefTypeOrTPHOrWildcardOrGeneric returnType, ResultSet resultSet) {
-		if(resultSet.resolveType(returnType).resolvedType.toString().equals(CONSTANTS.VOID)){
+		if(resultSet.resolveType(returnType).resolvedType.toString().equals("void")){
 			desc = desc + ")V";
 		}else {
 			desc = desc + ")" + "L"+resultSet.resolveType(returnType).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
@@ -43,41 +44,30 @@ public class DescriptorToString implements DescriptorVisitor, CONSTANTS {
 			if(method.hasGen()) {
 				String fpDesc = fp.getType().acceptTV(new TypeToDescriptor());
 				if(method.getGenericsAndBoundsMethod().containsKey(fpDesc)) {
-					String bound = getBound(fpDesc, method.getGenericsAndBoundsMethod());
+					desc += "L"+method.getGenericsAndBoundsMethod().get(fpDesc)+ ";";
-					desc += "L"+bound+ ";";
 				}else if(method.getGenericsAndBounds().containsKey(fpDesc)){
-					String bound = getBound(fpDesc, method.getGenericsAndBounds());
+					desc += "L"+method.getGenericsAndBounds().get(fpDesc)+ ";";
-					desc += "L"+bound+ ";";
 				}else {
 //					desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
 					String resType = resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor());
-					if(resType.contains(CONSTANTS.TPH)/*resType.subSequence(0, 4).equals("TPH ")*/) {
+					if(resType.subSequence(0, 4).equals("TPH ")) {
 						// Bound ist immer Object
 						desc += "L"+Type.getInternalName(Object.class)+ ";";
 					} else {
-						// TODO::
+						desc += "L"+resType+ ";";
-						if(method.getGenericsAndBounds().containsKey(resType)) {
-							String bound = getBound(resType, method.getGenericsAndBounds());
-							desc += "L"+bound+ ";";
-						}else if(method.getGenericsAndBoundsMethod().containsKey(resType)) {
-							String bound = getBound(resType, method.getGenericsAndBoundsMethod());
-							desc += "L"+bound+ ";";
-						} else {
-							desc += "L"+resType+ ";";
-						}
 					}
 				}
 			}
 			//TODO: generate a class java%% ... %%
-			else if(resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor()).contains(CONSTANTS.ANGLEBRACKET)){
+			else if(resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor()).contains("<")){
-				desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.toString().replace(".", "$$").replace(CONSTANTS.ANGLEBRACKET, "$$$").replace(">", "$$$")+ ";";
+				desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.toString().replace(".", "$$").replace("<", "$$$").replace(">", "$$$")+ ";";
 			}
 			else {
 				desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
 			}
 		}
 		
-		if(resultSet.resolveType(method.getReturnType()).resolvedType.toString().equals(CONSTANTS.VOID)) {
+		if(resultSet.resolveType(method.getReturnType()).resolvedType.toString().equals("void")) {
 			desc += ")V";
 		}else {
 			if(method.hasGen()) {
@@ -88,21 +78,11 @@ public class DescriptorToString implements DescriptorVisitor, CONSTANTS {
 					desc += ")L"+method.getGenericsAndBounds().get(ret)+ ";";
 				}else {
 					String resType = resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
-					if(resType.contains(CONSTANTS.TPH)/*resType.subSequence(0, 4).equals("TPH ")*/) {
+					if(resType.subSequence(0, 4).equals("TPH ")) {
 //						desc += ")" + "L"+method.getGenericsAndBoundsMethod().get(resType.substring(4)+"$")+ ";";
 						desc += ")" + "L"+Type.getInternalName(Object.class)+ ";";
 					} else {
-						// TODO::
+						desc += ")" + "L"+resType+ ";";
-						if(method.getGenericsAndBounds().containsKey(resType)) {
-							String bound = getBound(resType, method.getGenericsAndBounds());
-							desc += ")L"+bound+ ";";
-						}else if(method.getGenericsAndBoundsMethod().containsKey(resType)) {
-							String bound = getBound(resType, method.getGenericsAndBoundsMethod());
-							desc += ")L"+bound+ ";";
-						} else {
-							desc += ")L"+resType+ ";";
-						}
-//						desc += ")" + "L"+resType+ ";";
 					}
 				}
 			}else {
@@ -113,15 +93,6 @@ public class DescriptorToString implements DescriptorVisitor, CONSTANTS {
 		return desc;
 	}
 
-	private String getBound(String fpDesc, HashMap<String, String> genericsAndBounds) {
-		String start = genericsAndBounds.get(fpDesc);
-		while(genericsAndBounds.containsKey(start)) {
-			start = genericsAndBounds.get(start);
-		}
-		
-		return start;
-	}
-
 	@Override
 	public String visit(NormalConstructor constructor) {
 		String desc = "(";
@@ -135,17 +106,10 @@ public class DescriptorToString implements DescriptorVisitor, CONSTANTS {
 				if(constructor.getGenericsAndBounds().containsKey(fpDesc)){
 					desc += "L"+constructor.getGenericsAndBounds().get(fpDesc)+ ";";
 				}else {
-//					desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
+					desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
-					String resType = resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor());
-					if(resType.subSequence(0, 4).equals(CONSTANTS.TPH)) {
-						// Bound ist immer Object
-						desc += "L"+Type.getInternalName(Object.class)+ ";";
-					} else {
-						desc += "L"+resType+ ";";
-					}
 				}
 			}else {
-//				System.out.println("Cons has NO Gens");
+//				System.out.println("Cons has NOT Gens");
 				desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
 			}
 		}
@@ -160,7 +124,7 @@ public class DescriptorToString implements DescriptorVisitor, CONSTANTS {
 		while(itr.hasNext()) {
 			FormalParameter fp = itr.next();
 			String d = resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor());
-			if(d.contains(CONSTANTS.TPH) ||d.contains(CONSTANTS.ANGLEBRACKET)) {
+			if(d.substring(0, 4).equals("TPH ") ||d.contains("<")) {
 				desc += "L"+Type.getInternalName(Object.class)+ ";";
 			}else {
 				desc = desc + "L"+ d + ";";
@@ -169,7 +133,7 @@ public class DescriptorToString implements DescriptorVisitor, CONSTANTS {
 		
 		String retType = resultSet.resolveType(lambdaExpression.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
 		
-		if(retType.contains(CONSTANTS.TPH)|| retType.contains(CONSTANTS.ANGLEBRACKET)){
+		if(retType.substring(0, 4).equals("TPH ")|| retType.contains("<")){
 			desc += ")L"+Type.getInternalName(Object.class)+ ";";
 		}else {
 			desc = desc + ")"+"L"+retType+";";
@@ -185,7 +149,7 @@ public class DescriptorToString implements DescriptorVisitor, CONSTANTS {
 			RefTypeOrTPHOrWildcardOrGeneric rt = itr.next();
 			String d = resultSet.resolveType(rt).resolvedType.acceptTV(new TypeToDescriptor());
 			
-			if(d.contains(CONSTANTS.TPH) ||d.contains(CONSTANTS.ANGLEBRACKET)) {
+			if(d.substring(0, 4).equals("TPH ") ||d.contains("<")) {
 				desc += "L"+Type.getInternalName(Object.class)+ ";";
 			}else {
 				desc += "L"+ d + ";";
@@ -194,7 +158,7 @@ public class DescriptorToString implements DescriptorVisitor, CONSTANTS {
 		}
 		String retType = resultSet.resolveType(samMethod.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
 		
-		if(retType.contains(CONSTANTS.TPH)|| retType.contains(CONSTANTS.ANGLEBRACKET)){
+		if(retType.substring(0, 4).equals("TPH ")|| retType.contains("<")){
 			desc += ")L"+Type.getInternalName(Object.class)+ ";";
 		}else {
 			desc = desc + ")"+"L"+retType+";";
@@ -208,7 +172,7 @@ public class DescriptorToString implements DescriptorVisitor, CONSTANTS {
 		for(Expression e : methodFromMethodCall.getArgList().getArguments()) {
 			String d = resultSet.resolveType(e.getType()).resolvedType.acceptTV(new TypeToDescriptor());
 			
-			if(d.contains(CONSTANTS.TPH) ||d.contains(CONSTANTS.ANGLEBRACKET) || methodFromMethodCall.getReceiverName().contains("$$")) {
+			if(d.substring(0, 4).equals("TPH ") ||d.contains("<") || methodFromMethodCall.getReceiverName().contains("$$")) {
 				desc += "L"+Type.getInternalName(Object.class)+ ";";
 			}else {
 				if(methodFromMethodCall.getGenericsAndBoundsMethod().containsKey(d)) {
@@ -223,9 +187,9 @@ public class DescriptorToString implements DescriptorVisitor, CONSTANTS {
 		}
 		String retType = resultSet.resolveType(methodFromMethodCall.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
 		System.out.println("DescriptorToString retType = " + retType);
-		if(retType.equals(CONSTANTS.VOID)) {
+		if(retType.equals("void")) {
 			desc += ")V";
-		}else if(retType.contains(CONSTANTS.TPH)|| retType.contains(CONSTANTS.ANGLEBRACKET) || methodFromMethodCall.getReceiverName().contains("$$")){
+		}else if(retType.substring(0, 4).equals("TPH ")|| retType.contains("<") || methodFromMethodCall.getReceiverName().contains("$$")){
 			desc += ")L"+Type.getInternalName(Object.class)+ ";";
 		}else {
 			if(methodFromMethodCall.getGenericsAndBoundsMethod().containsKey(retType)) {
@@ -240,20 +204,4 @@ public class DescriptorToString implements DescriptorVisitor, CONSTANTS {
 		return desc;
 	}
 	
-	@Override
-	public String createDescForFunN(ArgumentList argumentList, String returnType) {
-		Iterator<Expression> itr1 = argumentList.getArguments().iterator();
-		String methDesc = "(";
-		while(itr1.hasNext()) {
-			methDesc += "L" + Type.getInternalName(Object.class) + ";";
-			itr1.next();
-		}
-		if (returnType.equals(CONSTANTS.VOID)){
-			methDesc += ")V";
-		} else {
-			methDesc += ")L" + Type.getInternalName(Object.class) + ";";
-		}
-		return methDesc;
-	}
-
 }

src/de/dhbwstuttgart/bytecode/descriptor/DescriptorVisitor.java

@@ -5,13 +5,11 @@ import de.dhbwstuttgart.bytecode.utilities.MethodFromMethodCall;
 import de.dhbwstuttgart.bytecode.utilities.NormalConstructor;
 import de.dhbwstuttgart.bytecode.utilities.NormalMethod;
 import de.dhbwstuttgart.bytecode.utilities.SamMethod;
-import de.dhbwstuttgart.syntaxtree.statement.ArgumentList;
 
 public interface DescriptorVisitor {
-	String visit(NormalMethod method);
+	public String visit(NormalMethod method);
-	String visit(NormalConstructor constructor);
+	public String visit(NormalConstructor constructor);
-	String visit(Lambda lambdaExpression);
+	public String visit(Lambda lambdaExpression);
-	String visit(SamMethod samMethod);
+	public String visit(SamMethod samMethod);
-	String visit(MethodFromMethodCall methodFromMethodCall);
+	public String visit(MethodFromMethodCall methodFromMethodCall);
-	String createDescForFunN(ArgumentList argumentList, String returnType);
 }

src/de/dhbwstuttgart/bytecode/descriptor/TypeToDescriptor.java

@@ -20,8 +20,7 @@ public class TypeToDescriptor implements TypeVisitor<String>{
 	@Override
 	public String visit(SuperWildcardType superWildcardType) {
 		System.out.println("\nWILDCARD ="+superWildcardType.getInnerType().toString().replace(".", "/"));
-		//return superWildcardType.getInnerType().toString().replace(".", "/");
+		return superWildcardType.getInnerType().toString().replace(".", "/");
-		return superWildcardType.getInnerType().acceptTV(new TypeToDescriptor());
 		//throw new NotImplementedException();
 	}
 
@@ -33,8 +32,7 @@ public class TypeToDescriptor implements TypeVisitor<String>{
 	@Override
 	public String visit(ExtendsWildcardType extendsWildcardType) {
 		System.out.println("\nWILDCARD extends ="+extendsWildcardType.getInnerType().toString().replace(".", "/"));
-		//return extendsWildcardType.getInnerType().toString().replace(".", "/");
+		return extendsWildcardType.getInnerType().toString().replace(".", "/");
-		return extendsWildcardType.getInnerType().acceptTV(new TypeToDescriptor());
 		//throw new NotImplementedException();
 	}
 

src/de/dhbwstuttgart/bytecode/signature/Signature.java

@@ -0,0 +1,484 @@
+package de.dhbwstuttgart.bytecode.signature;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+
+import org.objectweb.asm.Type;
+import org.objectweb.asm.signature.SignatureVisitor;
+import org.objectweb.asm.signature.SignatureWriter;
+
+import de.dhbwstuttgart.bytecode.descriptor.TypeToDescriptor;
+import de.dhbwstuttgart.bytecode.utilities.MethodAndTPH;
+import de.dhbwstuttgart.syntaxtree.AbstractASTWalker;
+import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
+import de.dhbwstuttgart.syntaxtree.Constructor;
+import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
+import de.dhbwstuttgart.syntaxtree.Method;
+import de.dhbwstuttgart.syntaxtree.statement.LambdaExpression;
+import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.typeinference.result.GenericInsertPair;
+import de.dhbwstuttgart.typeinference.result.ResolvedType;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+public class Signature {
+	private ClassOrInterface classOrInterface;
+	private HashMap<String, String> genericsAndBounds;
+	private HashMap<String, String> genericsAndBoundsMethod;
+	private SignatureWriter sw;
+	private Constructor constructor;
+	private Method method;
+	private HashMap<String,RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes;
+	private ResultSet resultSet;
+	private ArrayList<GenericInsertPair> commonPairs;
+	private ArrayList<GenericInsertPair> methodPairs;
+	
+	public Signature(ClassOrInterface classOrInterface, HashMap<String, String> genericsAndBounds,ArrayList<GenericInsertPair> commonPairs) {
+		this.classOrInterface = classOrInterface;
+		this.genericsAndBounds = genericsAndBounds;
+		this.commonPairs = commonPairs;
+		sw = new SignatureWriter();
+		createSignatureForClassOrInterface();
+	}
+
+	public Signature(Constructor constructor, HashMap<String, String> genericsAndBounds, 
+			HashMap<String,RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes,ResultSet resultSet,ArrayList<GenericInsertPair> methodPairs) {
+		this.constructor = constructor;
+		this.genericsAndBounds = genericsAndBounds;
+		this.methodParamsAndTypes = methodParamsAndTypes;
+		this.resultSet = resultSet;
+		this.methodPairs = methodPairs;
+		sw = new SignatureWriter();
+		createSignatureForConsOrMethod(this.constructor,true);
+	}
+
+	public Signature(Method method, HashMap<String, String> genericsAndBoundsMethod,HashMap<String, String> genericsAndBounds,
+			HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes, ResultSet resultSet, ArrayList<GenericInsertPair> methodPairs) {
+		this.method = method;
+		this.genericsAndBoundsMethod = genericsAndBoundsMethod;
+		this.genericsAndBounds = genericsAndBounds;
+		this.methodParamsAndTypes = methodParamsAndTypes;
+		this.resultSet = resultSet;
+		this.methodPairs = methodPairs;
+		sw = new SignatureWriter();
+		createSignatureForConsOrMethod(this.method,false);
+	}
+	
+	public Signature(LambdaExpression lambdaExpression,int numberOfParams) {
+		sw = new SignatureWriter();
+		createSignatureForFunN(lambdaExpression, numberOfParams);
+	}
+
+	private void createSignatureForFunN(LambdaExpression lambdaExpression, int numberOfParams) {
+		
+//		sw.visitClassBound().visitEnd();
+		for(int i = 0;i<numberOfParams;i++) {
+			int j = i+1;
+			sw.visitFormalTypeParameter("T"+ j);
+			// getBounds von Params
+			sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
+			sw.visitClassBound().visitEnd();
+		}
+
+		sw.visitFormalTypeParameter("R");
+		// getBounds vom Return-Type
+		sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
+		sw.visitClassBound().visitEnd();
+		// TODO: prüfe ob Return-Type = void,
+		sw.visitSuperclass().visitClassType(Type.getInternalName(Object.class));;
+		sw.visitEnd();
+	}
+
+	/**
+	 * Creates signature for a method or constructor with @see {@link SignatureWriter}
+	 * Signature looks like: 
+	 * <typevaliables (K:Ljava/lang/Object "Bounds")>(params L.. OR T.. Or basistape)ReturnType
+	 * 
+	 * @param method method or constructor
+	 * @param isConstructor true if constructor
+	 */
+	private void createSignatureForConsOrMethod(Method method, boolean isConstructor) {
+		Iterator<? extends GenericTypeVar> itr = method.getGenerics().iterator();
+		// visits all formal type parameter and visits their bounds <T:...;B:...;...>
+		while(itr.hasNext()) {
+			GenericTypeVar g = itr.next();
+			getBoundsOfTypeVar(g,genericsAndBoundsMethod);
+		}
+		
+		// Wenn die RückgabeType eine TPH ist, wird als generic behandelt
+		// z.B: Type = TPH K => wird eine Formal Type Parameter K$ erzeugt und Bound = Object
+		if(!isConstructor) {
+			String ret = resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToSignature());
+			System.out.println("RET:::: " + ret);
+			if(!ret.equals("V")) {
+				// TODO TypeToSignature nochmal kontrollieren und schauen ob man dort wirklich 
+				// T... braucht und L ...
+				if(ret.contains("$") && !ret.contains("$$")) {
+//					String g = ret.substring(4,ret.length())+"$";
+					if(genericsAndBounds.containsKey(ret)) {
+						genericsAndBoundsMethod.put(ret.substring(1), genericsAndBounds.get(ret.substring(1)));
+					}else {
+						sw.visitFormalTypeParameter(ret.substring(1));
+						sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
+						genericsAndBoundsMethod.put(ret.substring(1), Type.getInternalName(Object.class));
+						sw.visitClassBound().visitEnd();
+					}
+				}
+				
+				if(ret.contains("<")) {
+					RefType ref = (RefType) resultSet.resolveType(method.getReturnType()).resolvedType;
+					if(hasTPHs(ref)) {
+						createSignatureForParameterizedType(ref);
+					}
+					
+				}
+			}
+		}
+		
+		// Parameters
+		for(String paramName : methodParamsAndTypes.keySet()) {
+			RefTypeOrTPHOrWildcardOrGeneric t = methodParamsAndTypes.get(paramName);
+			String pT = t.acceptTV(new TypeToSignature()); 
+			// S.o
+//			if(pT.substring(0,4).equals("TPH ")) {
+			if(t instanceof TypePlaceholder) {
+//				String gP = pT.substring(4,pT.length())+"$";
+				String gP = t.acceptTV(new TypeToSignature());
+				if(!genericsAndBounds.containsKey(gP.substring(1)) && !genericsAndBoundsMethod.containsKey(gP.substring(1))) {
+					sw.visitFormalTypeParameter(gP.substring(1));
+					String bound = Type.getInternalName(Object.class);
+					boolean isTypeVar = false;
+					for(GenericInsertPair pair : methodPairs) {
+						if(pT.substring(1,pT.length()-1).equals(pair.TA1.getName())) {
+							bound = pair.TA2.getName()+"$";
+							isTypeVar = true;
+							break;
+						}
+					}
+					
+					if(isTypeVar) {
+						sw.visitClassBound().visitTypeVariable(bound);
+					}else {
+						sw.visitClassBound().visitClassType(bound);
+						sw.visitClassBound().visitEnd();
+					}
+					
+					genericsAndBoundsMethod.put(gP.substring(1), bound);
+				}
+			}
+			
+			if(pT.contains("<")) {
+				RefType ref = (RefType) methodParamsAndTypes.get(paramName);
+				if(hasTPHs(ref))
+					createSignatureForParameterizedType(ref);
+			}
+			
+			for(GenericInsertPair p:methodPairs) {
+				String name = p.TA1.getName()+"$";
+				if(!genericsAndBoundsMethod.containsKey(name)) {
+					sw.visitFormalTypeParameter(name);
+					sw.visitClassBound().visitTypeVariable(p.TA2.getName()+"$");
+					genericsAndBoundsMethod.put(name, p.TA2.getName()+"$");
+				}
+			}
+			
+			ArrayList<TypePlaceholder> types = new ArrayList<>();
+			ArrayList<TypePlaceholder> superTypes = new ArrayList<>();
+			
+			for(GenericInsertPair p : methodPairs) {
+				types.add(p.TA1);
+				superTypes.add(p.TA2);
+			}
+			
+			for(GenericInsertPair p : methodPairs) {
+				String name = p.TA2.getName()+"$";
+				if(!types.contains(p.TA2) && !genericsAndBoundsMethod.containsKey(name)) {
+					String bound = Type.getInternalName(Object.class);
+					sw.visitFormalTypeParameter(name);
+					sw.visitClassBound().visitClassType(bound);
+					genericsAndBoundsMethod.put(name, bound);
+					sw.visitClassBound().visitEnd();
+				}
+			}
+		}
+		
+		// visit each method-parameter to create the signature 
+		for(String paramName : methodParamsAndTypes.keySet()) {
+			RefTypeOrTPHOrWildcardOrGeneric t = methodParamsAndTypes.get(paramName);
+			// parameter type deswegen ist true
+			doVisitParamsOrReturn(t,true);
+		}
+		if(isConstructor || 
+				resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToSignature()).equals("V")) {
+			sw.visitReturnType().visitBaseType('V');
+		}else {
+			RefTypeOrTPHOrWildcardOrGeneric returnType = method.getReturnType();
+			// return type deswegen ist false
+			doVisitParamsOrReturn(returnType, false);
+		}
+//		sw.visitEnd();
+	}
+	
+	private void createSignatureForParameterizedType(RefType ref) {
+		ArrayList<GenericInsertPair> allPairs = getAllPairs(ref);
+		allPairs.addAll(methodPairs);
+		ArrayList<GenericInsertPair> simplifiedPairs = simplifyPairs(allPairs);
+		
+		HashMap<String, String> names = new HashMap<>();
+		
+		for(GenericInsertPair pair : simplifiedPairs) {
+			if(ref.getParaList().contains(pair.TA1)) {
+				String sub = pair.TA1.getName()+"$";
+				String superT = pair.TA2.getName()+"$";
+				names.put(sub, superT);
+			}
+		}
+		
+		for(String sub : names.keySet()) {
+			if(!genericsAndBoundsMethod.containsKey(sub) && !genericsAndBounds.containsKey(sub)) {
+				sw.visitFormalTypeParameter(sub);
+				String bound = names.get(sub);
+				sw.visitClassBound().visitTypeVariable(bound);
+				genericsAndBoundsMethod.put(sub, bound);
+			}
+		}
+		
+		for(String superT : names.values()) {
+			if(!names.containsKey(superT)) {
+				if(!genericsAndBoundsMethod.containsKey(superT) && !genericsAndBounds.containsKey(superT)) {
+					sw.visitFormalTypeParameter(superT);
+					sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
+					sw.visitClassBound().visitEnd();
+					genericsAndBoundsMethod.put(superT, Type.getInternalName(Object.class));
+				}
+			}
+		}
+		
+		for(RefTypeOrTPHOrWildcardOrGeneric p: ref.getParaList()) {
+			if(p instanceof TypePlaceholder) {
+				String name = ((TypePlaceholder) p).getName() + "$";
+				if(!genericsAndBoundsMethod.containsKey(name) && !genericsAndBounds.containsKey(name)) {
+					sw.visitFormalTypeParameter(name);
+					sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
+					sw.visitClassBound().visitEnd();
+					genericsAndBoundsMethod.put(name, Type.getInternalName(Object.class));
+				}
+			}
+		}
+	}
+
+	private ArrayList<GenericInsertPair> getAllPairs(RefType ref) {
+		final ArrayList<GenericInsertPair> res = new ArrayList<>();
+		for(RefTypeOrTPHOrWildcardOrGeneric p : ref.getParaList()) {
+			RefTypeOrTPHOrWildcardOrGeneric resolved = resultSet.resolveType(p).resolvedType;
+			if(resolved instanceof TypePlaceholder) {
+				resultSet.resolveType(p).additionalGenerics.forEach(ag ->{
+					if(!contains(res,ag)) {
+						res.add(ag);
+					}
+				});
+			}
+				
+		}
+		return res;
+	}
+	
+	private boolean contains(ArrayList<GenericInsertPair> pairs, GenericInsertPair genPair) {
+		for(int i=0; i<pairs.size();++i) {
+			GenericInsertPair p = pairs.get(i);
+			if(p.TA1.equals(genPair.TA1) && p.TA2.equals(genPair.TA2))
+				return true;
+		}
+		return false;
+	}
+	
+	private ArrayList<GenericInsertPair> simplifyPairs(ArrayList<GenericInsertPair> allPairs) {
+		ArrayList<GenericInsertPair> simplifiedPairs = new ArrayList<>();
+		
+		HashMap<TypePlaceholder, TypePlaceholder> subAndSuperTph = new HashMap<>();
+		for(GenericInsertPair p : allPairs) {
+			subAndSuperTph.put(p.TA1, p.TA2);
+		}
+		
+		subAndSuperTph.forEach((k,v)->System.out.println(k.getName() + " || " + v.getName()));
+		
+		int numOfVisitedPairs = 0;
+		for(TypePlaceholder subTph: subAndSuperTph.keySet()) {
+			
+			if(numOfVisitedPairs>=subAndSuperTph.size())
+				break;
+			
+			HashMap<Integer, TypePlaceholder> tphsInRel= new HashMap<>();
+			
+			tphsInRel.put(tphsInRel.size(), subTph);
+			TypePlaceholder superTph = subAndSuperTph.get(subTph);
+			tphsInRel.put(tphsInRel.size(), superTph);
+			
+			numOfVisitedPairs++;
+			
+			while(subAndSuperTph.containsKey(superTph)) {
+				superTph = subAndSuperTph.get(superTph);
+				tphsInRel.put(tphsInRel.size(), superTph);
+				numOfVisitedPairs++;
+			}
+			
+			// Subtype
+			TypePlaceholder subTphRes = tphsInRel.get(0);
+			// Die größte Supertype
+			TypePlaceholder superTphRes = tphsInRel.get(tphsInRel.size()-1);
+			
+			
+			while(subAndSuperTph.containsValue(subTphRes)) {
+				for(TypePlaceholder tph : subAndSuperTph.keySet()) {
+					if(subAndSuperTph.get(tph).equals(subTphRes)) {
+						subTphRes = tph;
+						break;
+					}
+				}
+				tphsInRel.put(0, subTphRes);
+				numOfVisitedPairs++;
+			}
+			
+			subTphRes = tphsInRel.get(0);
+			GenericInsertPair sPair = new GenericInsertPair(subTphRes, superTphRes);
+			simplifiedPairs.add(sPair);
+		}
+		return simplifiedPairs;
+	}
+	
+	private boolean hasTPHs(RefType ref) {
+		for(RefTypeOrTPHOrWildcardOrGeneric p : ref.getParaList()) {
+			System.out.println(p.acceptTV(new TypeToString()));
+			if(p.acceptTV(new TypeToString()).contains("WC")){
+				continue;
+			}
+			if(resultSet.resolveType(p).resolvedType instanceof TypePlaceholder)
+				return true;
+		}
+		return false;
+	}
+
+	/**
+	 * Visits parameter type or return type with {@link SignatureVisitor} to create
+	 * the method signature
+	 * @param t type of parameter or return type
+	 * @param isParameterType true if t is type of parameter
+	 */
+	private void doVisitParamsOrReturn(RefTypeOrTPHOrWildcardOrGeneric t, boolean isParameterType) {
+		String type = t.acceptTV(new TypeToString());
+		SignatureVisitor sv;
+		if(isParameterType) {
+			 sv = sw.visitParameterType();
+		}
+		else {
+			sv = sw.visitReturnType();
+		}
+		switch (type) {
+		case "RT":
+			String sig = t.acceptTV(new TypeToSignature());
+			sv.visitClassType(sig.substring(1, sig.length()));
+			break;
+		case "GRT":
+			GenericRefType g = (GenericRefType) t;
+			sv.visitTypeVariable(g.acceptTV(new TypeToSignature()).substring(1));
+			break;
+		case "TPH":
+			RefTypeOrTPHOrWildcardOrGeneric r = resultSet.resolveType(t).resolvedType;
+			// der Fall wenn die Type eine Interface ist, muss betrachtet werden
+			// Deswegen muss in ResutSet noch enthalten werden, ob die Type eine
+			// Interface oder eine Klasse ist.
+			
+			// das braucht man nicht es reicht: sv.visitTypeVariable(r.acceptTV(new TypeToSignature())
+			// 
+//			if(!r.acceptTV(new TypeToSignature()).substring(0, 4).equals("TPH ")) {
+			String sig2 = r.acceptTV(new TypeToSignature());
+			if(!(r instanceof TypePlaceholder)) {
+				
+//				sv.visitInterface().visitClassType(r.acceptTV(new TypeToSignature()));
+//				sv.visitClassType(r.acceptTV(new TypeToSignature()));
+				sv.visitClassType(sig2.substring(1, sig2.length()));
+			} else {
+				System.out.println(r.getClass()+" Signature TPH: "+r.acceptTV(new TypeToSignature()));
+//				sv.visitTypeVariable(r.acceptTV(new TypeToSignature()).substring(4)+"$");
+				sv.visitTypeVariable(sig2.substring(1, sig2.length()));
+			}
+			
+			break;
+		default:
+			if(!isParameterType)
+				sv.visitBaseType('V');
+			break;
+		}
+	}
+	/**
+	 * Creates signature for class or interface with {@link SignatureWriter}
+	 * Signature looks like: 
+	 * <typevaliables (K:Ljava/lang/Object "Bounds")>superclass
+	 */
+	private void createSignatureForClassOrInterface() {
+		Iterator<GenericTypeVar> itr = classOrInterface.getGenerics().iterator();
+
+		while(itr.hasNext()) {
+			GenericTypeVar g = itr.next();
+			getBoundsOfTypeVar(g,genericsAndBounds);
+		}
+		if(!commonPairs.isEmpty()) {
+			ArrayList<TypePlaceholder> types = new ArrayList<>();
+			ArrayList<TypePlaceholder> superTypes = new ArrayList<>();
+			
+			for(GenericInsertPair p : commonPairs) {
+				types.add(p.TA1);
+				superTypes.add(p.TA2);
+			}
+			
+			for(GenericInsertPair p : commonPairs) {
+				String t = p.TA1.getName()+"$";
+				String bound = p.TA2.getName()+"$";
+				sw.visitFormalTypeParameter(t);
+				sw.visitClassBound().visitTypeVariable(bound);
+				genericsAndBounds.put(t, bound);
+			}
+			
+			for(GenericInsertPair p : commonPairs) {
+				if(!types.contains(p.TA2)) {
+					String t = p.TA2.getName()+"$";
+					String bound = Type.getInternalName(Object.class);
+					sw.visitFormalTypeParameter(t);
+					sw.visitClassBound().visitClassType(bound);
+					genericsAndBounds.put(t, bound);
+					sw.visitClassBound().visitEnd();
+				}
+			}
+		}
+		String sClass = classOrInterface.getSuperClass().acceptTV(new TypeToSignature());
+		sw.visitSuperclass().visitClassType(sClass.substring(1, sClass.length()-1));
+		sw.visitEnd();
+	}
+	/**
+	 * Get bounds of type variable
+	 * @param g type variable
+	 * @param genAndBounds 
+	 */
+	private void getBoundsOfTypeVar(GenericTypeVar g, HashMap<String, String> genAndBounds) {
+		sw.visitFormalTypeParameter(g.getName());
+		
+		Iterator<? extends RefTypeOrTPHOrWildcardOrGeneric> bItr = g.getBounds().iterator(); 
+		while(bItr.hasNext()) {
+			RefTypeOrTPHOrWildcardOrGeneric b =bItr.next();
+			String boundDesc = b.acceptTV(new TypeToDescriptor());
+//			System.out.println("GetBounds: " + boundDesc);
+			// Ensure that <...> extends java.lang.Object OR ...
+			sw.visitClassBound().visitClassType(boundDesc);
+			genAndBounds.put(g.getName(), boundDesc);
+		}
+		sw.visitClassBound().visitEnd();
+	}
+	
+	public String toString() {
+		return sw.toString();
+	}
+	
+}

src/de/dhbwstuttgart/bytecode/signature/TypeToSignature.java

@@ -1,11 +1,8 @@
 package de.dhbwstuttgart.bytecode.signature;
 
-import java.util.ArrayList;
 import java.util.Iterator;
-import java.util.List;
-import java.util.Optional;
 
-import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericsGeneratorResult;
+import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
 import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
@@ -15,15 +12,6 @@ import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.syntaxtree.type.TypeVisitor;
 
 public class TypeToSignature implements TypeVisitor<String> {
-	private List<GenericsGeneratorResult> constraints;
-
-	public TypeToSignature() {
-		this.constraints = new ArrayList<>();
-	}
-
-	public TypeToSignature(List<GenericsGeneratorResult> constraints) {
-		this.constraints = constraints;
-	}
 
 	@Override
 	public String visit(RefType refType) {
@@ -45,10 +33,8 @@ public class TypeToSignature implements TypeVisitor<String> {
 //                } else {
 //                		params += "L"+param.toString().replace(".", "/");
 //                }
-                params += param.acceptTV(new TypeToSignature(constraints));
+                params += param.acceptTV(new TypeToSignature());
-
+//                if(it.hasNext())params += ";";
-                if(param instanceof TypePlaceholder)
-                	params += ";";
             }
             params += ">";
         }
@@ -60,33 +46,19 @@ public class TypeToSignature implements TypeVisitor<String> {
 	@Override
 	public String visit(SuperWildcardType superWildcardType) {
 //		throw new NotImplementedException();
-		String sig = "-" + superWildcardType.getInnerType().acceptTV(new TypeToSignature(constraints));
+		return "-" + superWildcardType.getInnerType().acceptTV(new TypeToSignature());
-		if(superWildcardType.getInnerType() instanceof TypePlaceholder)
-			sig += ";";
-		return sig;
 	}
 
 	@Override
 	public String visit(TypePlaceholder typePlaceholder) {
 //		return typePlaceholder.toString().replace(".", "/");
-		String name = typePlaceholder.getName();
+		return "T" + typePlaceholder.getName() + "$";
-
-		if(!constraints.isEmpty()){
-			Optional<GenericsGeneratorResult> equalName = getEqualTPHFromClassConstraints(constraints, name);
-			if(equalName.isPresent())
-				name = equalName.get().getConstraint().getLeft();
-		}
-
-		return "T" + name + "$";
 	}
 
 	@Override
 	public String visit(ExtendsWildcardType extendsWildcardType) {
 //		throw new NotImplementedException();
-		String sig = "+" + extendsWildcardType.getInnerType().acceptTV(new TypeToSignature(constraints));
+		return "+" + extendsWildcardType.getInnerType().acceptTV(new TypeToSignature());
-		if(extendsWildcardType.getInnerType() instanceof TypePlaceholder)
-			sig += ";";
-		return sig;
 	}
 
 	@Override
@@ -94,9 +66,4 @@ public class TypeToSignature implements TypeVisitor<String> {
 		return genericRefType.getParsedName().replace(".", "/");
 	}
 	
-	private Optional<GenericsGeneratorResult> getEqualTPHFromClassConstraints(List<GenericsGeneratorResult> listOfConstraints, String tph) {
-		return listOfConstraints.stream()
-				.filter(c -> c.getConstraint().getLeft().equals(tph) || c.getEqualsTPHs().contains(tph))
-				.findFirst();
-	}
 }

src/de/dhbwstuttgart/bytecode/utilities/KindOfLambda.java

@@ -1,37 +1,25 @@
 package de.dhbwstuttgart.bytecode.utilities;
 
+import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.syntaxtree.statement.*;
 
 import java.util.ArrayList;
-import java.util.Iterator;
 import java.util.List;
 
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
-import de.dhbwstuttgart.syntaxtree.FormalParameter;
-import de.dhbwstuttgart.syntaxtree.ParameterList;
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
 import de.dhbwstuttgart.syntaxtree.statement.Literal;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 
 public class KindOfLambda implements StatementVisitor{
-	private ParameterList params;
 	private boolean isInstanceCapturingLambda = false;
 	private List<RefTypeOrTPHOrWildcardOrGeneric> argumentList = new ArrayList<>();
-	private ArrayList<String> usedVars = new ArrayList<>();
-	private ArrayList<String> varsFromInnerLambdas = new ArrayList<>();
-	private boolean thisUsed = false;
-	private ArrayList<String> definedLocals = new ArrayList<>();
 	
 	public KindOfLambda(LambdaExpression lambdaExpression) {
-		this.params = lambdaExpression.params;
 		lambdaExpression.methodBody.accept(this);
 		
 	}
 	
-	public ArrayList<String> getUsedVars() {
-		return usedVars;
-	}
-	
 	public boolean isInstanceCapturingLambda() {
 		return this.isInstanceCapturingLambda;
 	}
@@ -40,20 +28,15 @@ public class KindOfLambda implements StatementVisitor{
 		return argumentList;
 	}
 	
-	public boolean isThisUsed() {
-		return thisUsed;
-	}
-	
 	@Override
 	public void visit(ArgumentList argumentList) {
-		argumentList.getArguments().forEach(a->a.accept(this));
+		// TODO Auto-generated method stub
 		
 	}
 
 	@Override
 	public void visit(LambdaExpression lambdaExpression) {
-		lambdaExpression.params.getFormalparalist().forEach(p->varsFromInnerLambdas.add(p.getName()));
+		
-		lambdaExpression.methodBody.accept(this);
 	}
 
 	@Override
@@ -63,8 +46,8 @@ public class KindOfLambda implements StatementVisitor{
 
 	@Override
 	public void visit(BinaryExpr binary) {
-		binary.lexpr.accept(this);
+		// TODO Auto-generated method stub
-		binary.rexpr.accept(this);
+		
 	}
 
 	@Override
@@ -99,9 +82,8 @@ public class KindOfLambda implements StatementVisitor{
 
 	@Override
 	public void visit(IfStmt ifStmt) {
-		ifStmt.expr.accept(this);
+		// TODO Auto-generated method stub
-		ifStmt.then_block.accept(this);
+		
-		ifStmt.else_block.accept(this);
 	}
 
 	@Override
@@ -112,45 +94,25 @@ public class KindOfLambda implements StatementVisitor{
 
 	@Override
 	public void visit(LocalVar localVar) {
-		boolean addVar = !contain(params, localVar.name) && !definedLocals.contains(localVar.name) &&
+		// TODO Auto-generated method stub
-				!varsFromInnerLambdas.contains(localVar.name) && !usedVars.contains(localVar.name);
-		if(addVar) {
-			argumentList.add(localVar.getType());
-			if(thisUsed) {
-				usedVars.add(1, localVar.name);
-			} else {
-				usedVars.add(0, localVar.name);
-			}
-			if(!isInstanceCapturingLambda)
-				isInstanceCapturingLambda=true;
-		}
-	}
 		
-	private boolean contain(ParameterList params2, String name) {
-		Iterator<FormalParameter> itr = params2.iterator();
-		while(itr.hasNext()) {
-			FormalParameter fp = itr.next();
-			if(fp.getName().equals(name))
-				return true;
-		}
-		return false;
 	}
 
 	@Override
 	public void visit(LocalVarDecl localVarDecl) {
-		definedLocals.add(localVarDecl.getName());
+		// TODO Auto-generated method stub
+		
 	}
 
 	@Override
 	public void visit(MethodCall methodCall) {
 		methodCall.receiver.accept(this);
-		methodCall.arglist.accept(this);
 	}
 
 	@Override
 	public void visit(NewClass methodCall) {
-		methodCall.receiver.accept(this);
+		// TODO Auto-generated method stub
-		methodCall.arglist.accept(this);
+		
 	}
 
 	@Override
@@ -166,7 +128,7 @@ public class KindOfLambda implements StatementVisitor{
 
 	@Override
 	public void visit(UnaryExpr unaryExpr) {
-		
+		throw new NotImplementedException();
 	}
 
 	@Override
@@ -194,20 +156,13 @@ public class KindOfLambda implements StatementVisitor{
 
 	@Override
 	public void visit(This aThis) {
-		if(!thisUsed) {
+		this.isInstanceCapturingLambda = true;
-			thisUsed = true;
+		this.argumentList.add(aThis.getType());
-			this.argumentList.add(0,aThis.getType());
-		}
-		if(!isInstanceCapturingLambda) {
-			this.isInstanceCapturingLambda = true;
-			
-		}
 	}
 
 	@Override
 	public void visit(WhileStmt whileStmt) {
-		whileStmt.expr.accept(this);
+		// TODO Auto-generated method stub
-		whileStmt.loopBlock.accept(this);
 		
 	}
 

src/de/dhbwstuttgart/bytecode/utilities/MethodAndTPH.java

@@ -0,0 +1,29 @@
+package de.dhbwstuttgart.bytecode.utilities;
+
+import java.util.ArrayList;
+
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.typeinference.result.GenericInsertPair;
+
+public class MethodAndTPH {
+	
+	private String name;
+	private final ArrayList<TypePlaceholder> tphs = new ArrayList<>();
+	private final ArrayList<GenericInsertPair> pairs = new ArrayList<>();
+
+	public MethodAndTPH(String name) {
+		this.name = name;
+	}
+
+	public ArrayList<TypePlaceholder> getTphs() {
+		return tphs;
+	}
+	
+	public ArrayList<GenericInsertPair> getPairs(){
+		return pairs;
+	}
+	
+	public String getName() {
+		return name;
+	}
+}

src/de/dhbwstuttgart/bytecode/utilities/MethodFromMethodCall.java

@@ -23,7 +23,6 @@ public class MethodFromMethodCall {
 		this.genericsAndBounds = genericsAndBounds;
 	}
 	
-	
 	public ArgumentList getArgList() {
 		return argList;
 	}

src/de/dhbwstuttgart/core/ConsoleInterface.java

@@ -0,0 +1,16 @@
+package de.dhbwstuttgart.core;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class ConsoleInterface {
+	private static final String directory = System.getProperty("user.dir");
+
+	public static void main(String[] args) throws IOException, ClassNotFoundException {
+		List<File> input = Arrays.asList(args).stream().map((s -> new File(s))).collect(Collectors.toList());
+		JavaTXCompiler compiler = new JavaTXCompiler(input);
+		compiler.typeInference();
+	}
+}

src/de/dhbwstuttgart/core/JavaTXCompiler.java

@@ -0,0 +1,294 @@
+package de.dhbwstuttgart.core;
+
+
+import de.dhbwstuttgart.bytecode.BytecodeGen;
+import de.dhbwstuttgart.environment.CompilationEnvironment;
+import de.dhbwstuttgart.parser.JavaTXParser;
+import de.dhbwstuttgart.parser.NullToken;
+import de.dhbwstuttgart.parser.scope.GenericsRegistry;
+import de.dhbwstuttgart.parser.SyntaxTreeGenerator.SyntaxTreeGenerator;
+import de.dhbwstuttgart.parser.antlr.Java8Parser.CompilationUnitContext;
+import de.dhbwstuttgart.parser.scope.JavaClassName;
+import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
+import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
+import de.dhbwstuttgart.syntaxtree.ParameterList;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
+import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
+import de.dhbwstuttgart.typeinference.constraints.Constraint;
+import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
+import de.dhbwstuttgart.typeinference.constraints.Pair;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+import de.dhbwstuttgart.typeinference.typeAlgo.TYPE;
+import de.dhbwstuttgart.typeinference.unify.RuleSet;
+import de.dhbwstuttgart.typeinference.unify.TypeUnify;
+import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask;
+import de.dhbwstuttgart.typeinference.unify.distributeVariance;
+import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
+import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
+import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class JavaTXCompiler {
+	final boolean parallel = true;
+    final CompilationEnvironment environment;
+    public final Map<File, SourceFile> sourceFiles = new HashMap<>();
+    Boolean log = true; //gibt an ob ein Log-File nach System.getProperty("user.dir")+"/test/logFiles/log" geschrieben werden soll?
+
+    public JavaTXCompiler(File sourceFile) throws IOException, ClassNotFoundException {
+        this(Arrays.asList(sourceFile));
+    }
+
+    public JavaTXCompiler(File sourceFile, Boolean log) throws IOException, ClassNotFoundException {
+    	this(sourceFile);
+    	this.log = log;
+    }
+    
+    public JavaTXCompiler(List<File> sources) throws IOException, ClassNotFoundException {
+        environment = new CompilationEnvironment(sources);
+        for (File s : sources) {
+            sourceFiles.put(s, parse(s));
+        }
+    }
+
+    public ConstraintSet<Pair> getConstraints() throws ClassNotFoundException {
+        List<ClassOrInterface> allClasses = new ArrayList<>();//environment.getAllAvailableClasses();
+        for (SourceFile sf : sourceFiles.values()) {
+            allClasses.addAll(sf.getClasses());
+        }
+        List<ClassOrInterface> importedClasses = new ArrayList<>();
+        //Alle Importierten Klassen in allen geparsten Sourcefiles kommen ins FC
+        for (File forSourceFile : sourceFiles.keySet())
+            for (JavaClassName name : sourceFiles.get(forSourceFile).getImports()) {
+                //TODO: Hier werden imports von eigenen (.jav) Klassen nicht beachtet
+                ClassOrInterface importedClass = ASTFactory.createClass(
+                        ClassLoader.getSystemClassLoader().loadClass(name.toString()));
+                importedClasses.add(importedClass);
+            }
+        allClasses.addAll(importedClasses);
+
+        return new TYPE(sourceFiles.values(), allClasses).getConstraints();
+    }
+
+    public List<ClassOrInterface> getAvailableClasses(SourceFile forSourceFile) throws ClassNotFoundException {
+        List<ClassOrInterface> allClasses = new ArrayList<>();//environment.getAllAvailableClasses();
+        for (SourceFile sf : sourceFiles.values()) {
+            allClasses.addAll(sf.getClasses());
+        }
+        List<ClassOrInterface> importedClasses = new ArrayList<>();
+        for (JavaClassName name : forSourceFile.getImports()) {
+            //TODO: Hier werden imports von eigenen (.jav) Klassen nicht beachtet
+            ClassOrInterface importedClass = ASTFactory.createClass(
+                    ClassLoader.getSystemClassLoader().loadClass(name.toString()));
+            importedClasses.add(importedClass);
+            allClasses.addAll(importedClasses);
+        }
+        return allClasses;
+    }
+
+    public List<ResultSet> typeInference() throws ClassNotFoundException {
+        List<ClassOrInterface> allClasses = new ArrayList<>();//environment.getAllAvailableClasses();
+        //Alle Importierten Klassen in allen geparsten Sourcefiles kommen ins FC
+        for(SourceFile sf : this.sourceFiles.values()) {
+            allClasses.addAll(getAvailableClasses(sf));
+            allClasses.addAll(sf.getClasses());
+        }
+
+        final ConstraintSet<Pair> cons = getConstraints();
+
+        FiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses);
+        System.out.println(finiteClosure);
+        ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(cons);
+
+        TypeUnify unify = new TypeUnify();
+        Set<Set<UnifyPair>> results = new HashSet<>();
+        try {
+			FileWriter logFile = new FileWriter(new File(System.getProperty("user.dir")+"/test/logFiles/"+"log"));
+			logFile.write("FC:\\" + finiteClosure.toString()+"\n");
+			for(SourceFile sf : this.sourceFiles.values()) {
+				logFile.write(ASTTypePrinter.print(sf));
+			}
+			logFile.flush();
+			Set<TypeUnifyTask> forks = new HashSet<>();
+			Set<List<Constraint<UnifyPair>>> cardProd = unifyCons.cartesianProduct(); 
+			for (List<Constraint<UnifyPair>> xCons : cardProd ){
+				Set<UnifyPair> xConsSet = new HashSet<>();
+				for (Constraint<UnifyPair> constraint : xCons) {
+					xConsSet.addAll(constraint);
+				}
+				//.collect(Collectors.toCollection(ArrayList::new))))
+				System.out.println(xConsSet);
+				Set<String> paraTypeVarNames = allClasses.stream().map(x -> x.getMethods().stream().map(y -> y.getParameterList().getFormalparalist()
+						.stream().filter(z -> z.getType() instanceof TypePlaceholder)
+						.map(z -> ((TypePlaceholder)z.getType()).getName()).collect(Collectors.toCollection(HashSet::new)))
+						.reduce(new HashSet<String>(), (a,b) -> { a.addAll(b); return a;}, (a,b) -> { a.addAll(b); return a;} )  )
+						.reduce(new HashSet<String>(), (a,b) -> { a.addAll(b); return a;} );
+				
+				Set<String> returnTypeVarNames = allClasses.stream().map(x -> x.getMethods().stream().filter(y -> y.getReturnType() instanceof TypePlaceholder)
+						.map(z -> ((TypePlaceholder)z.getReturnType()).getName()).collect(Collectors.toCollection(HashSet::new))).reduce((a,b) -> { a.addAll(b); return a;} ).get();
+				
+				
+				xConsSet = xConsSet.stream().map(x -> { 
+					//Hier muss ueberlegt werden, ob
+					//1. alle Argument- und Retuntyp-Variablen in allen UnifyPairs 
+					//   mit disableWildcardtable() werden.
+					//2. alle Typvariablen mit Argument- oder Retuntyp-Variablen 
+					//in Beziehung auch auf disableWildcardtable() gesetzt werden muessen
+					//PL 2018-04-23
+					if ((x.getLhsType() instanceof PlaceholderType)) {
+						if (paraTypeVarNames.contains(x.getLhsType().getName())) { 
+							((PlaceholderType)x.getLhsType()).setVariance((byte)1);
+							((PlaceholderType)x.getLhsType()).disableWildcardtable();
+						}
+						if (returnTypeVarNames.contains(x.getLhsType().getName())) {
+							((PlaceholderType)x.getLhsType()).setVariance((byte)-1);
+							((PlaceholderType)x.getLhsType()).disableWildcardtable();
+						}
+					}
+					if ((x.getRhsType() instanceof PlaceholderType)) {
+						if (paraTypeVarNames.contains(x.getRhsType().getName())) {
+							((PlaceholderType)x.getRhsType()).setVariance((byte)1);
+							((PlaceholderType)x.getRhsType()).disableWildcardtable();
+						}
+						if (returnTypeVarNames.contains(x.getRhsType().getName())) {
+							((PlaceholderType)x.getRhsType()).setVariance((byte)-1);
+							((PlaceholderType)x.getRhsType()).disableWildcardtable();
+						}	
+					}
+					return x;//HIER DIE JEWEILS RECHT BZW. LINKE SEITE AUF GLEICHE VARIANZ SETZEN WIE DIE JEWEILS ANDERE SEITE 
+				}).map( y -> { 
+						if ((y.getLhsType() instanceof PlaceholderType) && (y.getRhsType() instanceof PlaceholderType)) {
+							if (((PlaceholderType)y.getLhsType()).getVariance() != 0  && ((PlaceholderType)y.getRhsType()).getVariance() == 0) { 
+								((PlaceholderType)y.getRhsType()).setVariance(((PlaceholderType)y.getLhsType()).getVariance()); 
+							} 
+							if (((PlaceholderType)y.getLhsType()).getVariance() == 0  && ((PlaceholderType)y.getRhsType()).getVariance() != 0) { 
+								((PlaceholderType)y.getLhsType()).setVariance(((PlaceholderType)y.getRhsType()).getVariance()); 
+							} 
+						}
+					return y; } )
+				.collect(Collectors.toCollection(HashSet::new));
+					varianceInheritance(xConsSet);
+					if (parallel) {
+						//Set<Set<UnifyPair>> result = unify.unifySequential(xConsSet, finiteClosure, logFile, log);
+						Set<UnifyPair> eq = new HashSet<>(xConsSet);
+						TypeUnifyTask fork = new TypeUnifyTask(eq, finiteClosure, true, logFile, log);
+						forks.add(fork);
+						fork.fork();
+					}
+					else {
+						Set<Set<UnifyPair>> result = unify.unifySequential(xConsSet, finiteClosure, logFile, log);
+						System.out.println("RESULT: " + result);
+		    			logFile.write("RES: " + result.toString()+"\n");
+		    			logFile.flush();
+		    			results.addAll(result);
+					}
+			}
+			for (TypeUnifyTask fork : forks) {
+				try {
+					Set<Set<UnifyPair>> result = fork.join();
+					System.out.println("RESULT: " + result);
+					logFile.write("RES: " + result.toString()+"\n");
+					logFile.flush();
+					results.addAll(result);
+				}
+				catch (ConcurrentModificationException v) {
+					v.printStackTrace();
+					while (v.getCause() instanceof ConcurrentModificationException) {
+						v = (ConcurrentModificationException)v.getCause();
+					}
+					System.out.println(v);
+				}
+			}
+        }
+    	catch (IOException e) { }
+			
+		return results.stream().map((unifyPairs ->
+               new ResultSet(UnifyTypeFactory.convert(unifyPairs, generateTPHMap(cons))))).collect(Collectors.toList());
+        }
+    
+    /**
+	 * Vererbt alle Variancen
+	 * @param eq The set of constraints
+	 */
+	private void varianceInheritance(Set<UnifyPair> eq) {
+		Set<PlaceholderType> usedTPH = new HashSet<>();
+		Set<PlaceholderType> phSet = eq.stream().map(x -> { 
+			Set<PlaceholderType> pair = new HashSet<>();
+			if (x.getLhsType() instanceof PlaceholderType) pair.add((PlaceholderType)x.getLhsType());
+			if (x.getRhsType() instanceof PlaceholderType) pair.add((PlaceholderType)x.getRhsType());
+			return pair;
+		}).reduce(new HashSet<>(), (a,b) -> { a.addAll(b); return a;} , (c,d) -> { c.addAll(d); return c;});
+		
+		ArrayList<PlaceholderType> phSetVariance =  new ArrayList<>(phSet);
+		phSetVariance.removeIf(x -> (x.getVariance() == 0));
+		while(!phSetVariance.isEmpty()) {
+			PlaceholderType a = phSetVariance.remove(0);
+			usedTPH.add(a);
+			//HashMap<PlaceholderType,Integer> ht = new HashMap<>();
+			//ht.put(a, a.getVariance());
+			Set<UnifyPair> eq1 = new HashSet<>(eq); 
+			eq1.removeIf(x -> !(x.getLhsType() instanceof PlaceholderType && ((PlaceholderType)x.getLhsType()).equals(a)));
+			eq1.stream().forEach(x -> { x.getRhsType().accept(new distributeVariance(), a.getVariance());});
+			eq1 = new HashSet<>(eq); 
+			eq1.removeIf(x -> !(x.getRhsType() instanceof PlaceholderType && ((PlaceholderType)x.getRhsType()).equals(a)));
+			eq1.stream().forEach(x -> { x.getLhsType().accept(new distributeVariance(), a.getVariance());});
+			phSetVariance =  new ArrayList<>(phSet);
+			phSetVariance.removeIf(x -> (x.getVariance() == 0 || usedTPH.contains(x)));
+		}		
+}
+
+    private Map<String, TypePlaceholder> generateTPHMap(ConstraintSet<Pair> constraints) {
+        HashMap<String, TypePlaceholder> ret = new HashMap<>();
+        constraints.map((Pair p) -> {
+            if (p.TA1 instanceof TypePlaceholder) {
+                ret.put(((TypePlaceholder) p.TA1).getName(), (TypePlaceholder) p.TA1);
+            }
+            if (p.TA2 instanceof TypePlaceholder) {
+                ret.put(((TypePlaceholder) p.TA2).getName(), (TypePlaceholder) p.TA2);
+            }
+            return null;
+        });
+        return ret;
+    }
+
+    private SourceFile parse(File sourceFile) throws IOException, java.lang.ClassNotFoundException {
+        CompilationUnitContext tree = JavaTXParser.parse(sourceFile);
+        SyntaxTreeGenerator generator = new SyntaxTreeGenerator(environment.getRegistry(sourceFile), new GenericsRegistry(null));
+        SourceFile ret = generator.convert(tree, environment.packageCrawler);
+        return ret;
+    }
+    // um pfad erweitern
+    public void generateBytecode(String path) throws ClassNotFoundException, IOException {
+    		for(File f : sourceFiles.keySet()) {
+    			HashMap<String,byte[]> classFiles = new HashMap<>();
+    			SourceFile sf = sourceFiles.get(f);
+    			List<ResultSet> typeinferenceResult = this.typeInference();
+    			BytecodeGen bytecodeGen = new BytecodeGen(classFiles,typeinferenceResult,sf,path);
+//    			BytecodeGen bytecodeGen = new BytecodeGen(classFiles,typeinferenceResult.get(0));
+        		bytecodeGen.visit(sf);
+        		this.writeClassFile(bytecodeGen.getClassFiles(), path);
+    		}
+    }
+
+	private void writeClassFile(HashMap<String, byte[]> classFiles, String path) throws IOException {
+		FileOutputStream output;
+		for(String name : classFiles.keySet()) {
+			byte[] bytecode = classFiles.get(name);
+			System.out.println("generating "+name+ ".class file ...");
+			//output = new FileOutputStream(new File(System.getProperty("user.dir") + "/testBytecode/generatedBC/" +name+".class"));
+			output = new FileOutputStream(new File(path +name+".class"));
+			output.write(bytecode);
+			output.close();
+			System.out.println(name+".class file generated");
+		}
+	}
+}

src/de/dhbwstuttgart/environment/CompilationEnvironment.java

@@ -4,12 +4,18 @@ import java.io.File;
 import java.io.IOException;
 import java.net.MalformedURLException;
 import java.net.URL;
+import java.net.URLClassLoader;
 import java.util.*;
 
-import com.google.common.collect.Lists;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
-import org.antlr.v4.runtime.tree.TerminalNode;
+import org.reflections.Reflections;
+import org.reflections.scanners.ResourcesScanner;
+import org.reflections.scanners.SubTypesScanner;
+import org.reflections.util.ClasspathHelper;
+import org.reflections.util.ConfigurationBuilder;
+import org.reflections.util.FilterBuilder;
 
 import de.dhbwstuttgart.exceptions.DebugException;
 import de.dhbwstuttgart.parser.JavaTXParser;
@@ -43,7 +49,8 @@ public class CompilationEnvironment {
 		 *
 		 */
 		//String bootClassPath = System.getProperty("sun.boot.class.path");
-		//		DirectoryClassLoader cl = DirectoryClassLoader.getPlatformClassLoader();
+		//		ClassLoader cl = ClassLoader.getPlatformClassLoader();
+				ClassLoader cl = ClassLoader.getSystemClassLoader();
 				String bootClassPath = System.getProperty("java.class.path");
 		librarys = new ArrayList<>();
 		for(String path : bootClassPath.split(File.pathSeparator)) {
@@ -60,44 +67,13 @@ public class CompilationEnvironment {
         this.packageCrawler = new PackageCrawler(librarys);
 	}
 
-	public JavaClassRegistry getRegistry(File forSourceFile, ClassLoader classLoader) throws ClassNotFoundException, IOException {
+	public JavaClassRegistry getRegistry(File forSourceFile) throws ClassNotFoundException, IOException {
 		Map<String, Integer> allNames;
 		CompilationUnitContext tree = JavaTXParser.parse(forSourceFile);
-		allNames = GatherNames.getNames(tree, packageCrawler, classLoader);
+		allNames = GatherNames.getNames(tree, packageCrawler);
-		for(Class c : loadDefaultPackageClasses(forSourceFile, classLoader)){
-			allNames.put(c.getName(), c.getTypeParameters().length);
-		}
 		return new JavaClassRegistry(allNames);
 	}
 
-	public static List<Class> loadDefaultPackageClasses(File forSourceFile, ClassLoader classLoader) throws IOException, ClassNotFoundException {
-		List<Class> ret = new ArrayList<>();
-		String packageName = getPackageName(JavaTXParser.parse(forSourceFile));
-		//Set classLoader to include default package for this specific source file
-		File dir = new File(forSourceFile.getAbsoluteFile().getParent());
-		String dirPath = dir.toString() + "/";
-		if(packageName.length()>0)dirPath = dirPath.substring(0,dirPath.length() - packageName.length());
-		String path = dirPath;
-		ArrayList<File> defaultPath = Lists.newArrayList(new File(path));
-		classLoader = new DirectoryClassLoader(defaultPath, classLoader);
-		//Gather all names in the default package for this source file (classes that are imported by default)
-		File [] files = dir.listFiles((dir1, name) -> name.endsWith(".class"));
-		if(files != null)for (File classFile : files) {
-			String className = classFile.getName().substring(0,classFile.getName().length()-6);
-			ret.add(classLoader.loadClass(packageName + className));
-        }
-		return ret;
-	}
-
-	private static String getPackageName(CompilationUnitContext forTree){
-		String packageName = "";
-		if(forTree.packageDeclaration() != null && forTree.packageDeclaration().Identifier() != null)
-		    for(TerminalNode subPackage : forTree.packageDeclaration().Identifier()){
-			    packageName += subPackage.toString() + ".";
-		}
-		return packageName;
-	}
-
 	public List<ClassOrInterface> getAllAvailableClasses() {
 		List<ClassOrInterface> ret = new ArrayList<>();
 		for(Class c : new PackageCrawler(librarys).getAllAvailableClasses()){

src/de/dhbwstuttgart/environment/PackageCrawler.java

@@ -26,11 +26,11 @@ public class PackageCrawler {
 	
     public Set<Class<?>> getClassesInPackage(String packageName){
     	/*
-        List<DirectoryClassLoader> classLoadersList = new LinkedList<DirectoryClassLoader>();
+        List<ClassLoader> classLoadersList = new LinkedList<ClassLoader>();
         classLoadersList.add(Thread.currentThread().getContextClassLoader());
         classLoadersList.add(ClasspathHelper.staticClassLoader());
         classLoadersList.add(Thread.currentThread().getContextClassLoader().getParent());
-        classLoadersList.add(DirectoryClassLoader.getSystemClassLoader());
+        classLoadersList.add(ClassLoader.getSystemClassLoader());
         String bootClassPath = System.getProperty("sun.boot.class.path");
         ArrayList<URL> urlList = new ArrayList<>();
         for(String path : bootClassPath.split(";")) {
@@ -41,7 +41,7 @@ public class PackageCrawler {
 			}
         }
         URL[] urls = urlList.toArray(new URL[0]);
-        classLoadersList.add(new URLClassLoader(urls, DirectoryClassLoader.getSystemClassLoader()));
+        classLoadersList.add(new URLClassLoader(urls, ClassLoader.getSystemClassLoader()));
         */
         Reflections reflections = new Reflections(new ConfigurationBuilder()
                 .setScanners(new SubTypesScanner(false /* don't exclude Object.class */), new ResourcesScanner())

src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/FCGenerator.java

@@ -13,8 +13,6 @@ import de.dhbwstuttgart.typeinference.unify.model.*;
 import java.util.*;
 import java.util.stream.Collectors;
 
-import org.antlr.v4.runtime.Token;
-
 public class FCGenerator {
     /**
      * Baut die FiniteClosure aus availableClasses.
@@ -22,25 +20,18 @@ public class FCGenerator {
      *
      * @param availableClasses - Alle geparsten Klassen
      */
-    public static Set<UnifyPair> toUnifyFC(Collection<ClassOrInterface> availableClasses, ClassLoader classLoader) throws ClassNotFoundException {
+    public static Set<UnifyPair> toUnifyFC(Collection<ClassOrInterface> availableClasses) throws ClassNotFoundException {
-        return toFC(availableClasses, classLoader).stream().map(t -> UnifyTypeFactory.convert(t)).collect(Collectors.toSet());
+        return toFC(availableClasses).stream().map(t -> UnifyTypeFactory.convert(t)).collect(Collectors.toSet());
     }
 
-    public static Set<Pair> toFC(Collection<ClassOrInterface> availableClasses, ClassLoader classLoader) throws ClassNotFoundException {
+    public static Set<Pair> toFC(Collection<ClassOrInterface> availableClasses) throws ClassNotFoundException {
         HashSet<Pair> pairs = new HashSet<>();
-        //PL 2018-09-18: gtvs vor die for-Schleife gezogen, damit immer die gleichen Typeplaceholder eingesetzt werden.
-        HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> gtvs = new HashMap<>();
         for(ClassOrInterface cly : availableClasses){
-            pairs.addAll(getSuperTypes(cly, availableClasses, gtvs, classLoader));
+            pairs.addAll(getSuperTypes(cly, availableClasses));
         }
         return pairs;
     }
 
-    
-    	
-    	
-
-
     /**
      * Bildet eine Kette vom übergebenen Typ bis hin zum höchsten bekannten Typ
      * Als Generics werden TPHs benutzt, welche der Unifikationsalgorithmus korrekt interpretieren muss.
@@ -48,8 +39,8 @@ public class FCGenerator {
      * @param forType
      * @return
      */
-    private static List<Pair> getSuperTypes(ClassOrInterface forType, Collection<ClassOrInterface> availableClasses, ClassLoader classLoader) throws ClassNotFoundException {
+    private static List<Pair> getSuperTypes(ClassOrInterface forType, Collection<ClassOrInterface> availableClasses) throws ClassNotFoundException {
-        return getSuperTypes(forType, availableClasses, new HashMap<>(), classLoader);
+        return getSuperTypes(forType, availableClasses, new HashMap<>());
     }
 
     /**
@@ -61,7 +52,7 @@ public class FCGenerator {
      * @throws ClassNotFoundException
      */
     private static List<Pair> getSuperTypes(ClassOrInterface forType, Collection<ClassOrInterface> availableClasses,
-                                            HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> gtvs, ClassLoader classLoader) throws ClassNotFoundException {
+                                            HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> gtvs) throws ClassNotFoundException {
         List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
         //Die GTVs, die in forType hinzukommen:
         HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> newGTVs = new HashMap<>();
@@ -86,7 +77,7 @@ public class FCGenerator {
             ClassOrInterface superClass;
             if(!hasSuperclass.isPresent()) //Wenn es die Klasse in den available Klasses nicht gibt wird sie im Classpath gesucht. Ansonsten Exception
             {
-                superClass = ASTFactory.createClass(classLoader.loadClass(superType.getName().toString()));
+                superClass = ASTFactory.createClass(ClassLoader.getSystemClassLoader().loadClass(superType.getName().toString()));
             }else{
                 superClass = hasSuperclass.get();
             }
@@ -120,7 +111,7 @@ public class FCGenerator {
             if(superClass.getClassName().equals(ASTFactory.createObjectClass().getClassName())){
                 superTypes = Arrays.asList(new Pair(ASTFactory.createObjectType(), ASTFactory.createObjectType(), PairOperator.SMALLER));
             }else{
-                superTypes = getSuperTypes(superClass, availableClasses, newGTVs, classLoader);
+                superTypes = getSuperTypes(superClass, availableClasses, newGTVs);
             }
 
             retList.add(ret);

src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/StatementGenerator.java

@@ -17,19 +17,17 @@ import org.antlr.v4.runtime.Token;
 import org.antlr.v4.runtime.tree.TerminalNode;
 
 import java.util.*;
-import java.util.stream.Collectors;
 
 public class StatementGenerator {
 
     private JavaClassRegistry reg;
-    private Map<String, RefTypeOrTPHOrWildcardOrGeneric> fields; //PL 2018-11-01 fields eingefuegt, damit die fields immer die gleiche TPH bekommen
     private Map<String, RefTypeOrTPHOrWildcardOrGeneric> localVars;
     private GenericsRegistry generics;
+    private String VAR_KEYWORD = "var";
 
-    public StatementGenerator(JavaClassRegistry reg, GenericsRegistry generics, Map<String, RefTypeOrTPHOrWildcardOrGeneric> fields, Map<String, RefTypeOrTPHOrWildcardOrGeneric> localVars){
+    public StatementGenerator(JavaClassRegistry reg, GenericsRegistry generics, Map<String, RefTypeOrTPHOrWildcardOrGeneric> localVars){
         this.reg = reg;
         this.generics = generics;
-        this.fields = fields;
         this.localVars = localVars;
     }
 
@@ -210,12 +208,7 @@ public class StatementGenerator {
         }else throw new NotImplementedException();
 
         ArgumentList argumentList = convert(methodInvocationContext.argumentList());
-        ArrayList<RefTypeOrTPHOrWildcardOrGeneric> argTypes = argumentList.getArguments().stream()
+        MethodCall ret = new MethodCall(TypePlaceholder.fresh(methodInvocationContext.getStart()), getReceiver(receiver), name, argumentList, methodInvocationContext.getStart());
-        		.map(x -> TypePlaceholder.fresh(methodInvocationContext.getStart()))
-        		.collect(Collectors.toCollection(ArrayList::new));
-        MethodCall ret = new MethodCall(TypePlaceholder.fresh(methodInvocationContext.getStart()), 
-        		getReceiver(receiver), name, argumentList, TypePlaceholder.fresh(methodInvocationContext.getStart()), 
-        		argTypes, methodInvocationContext.getStart());
         return ret;
     }
 
@@ -246,14 +239,9 @@ public class StatementGenerator {
             if(localVars.get(expression) != null){
                 return new LocalVar(expression, localVars.get(expression), offset);
             }else{
-            if(fields.get(expression) != null){//PL 2018-11-01 fields eingefuegt, damit die fields immer die gleiche TPH bekommen
-            	return new FieldVar(new This(offset), expression, fields.get(expression), offset);
-                
-            } else {
-            	//kann eigentlich nicht vorkommen
                 //Dann Muss es ein Feld sein!
                 return new FieldVar(new This(offset), expression, TypePlaceholder.fresh(offset), offset);
-            }}
+            }
         }
         return generateFieldVarOrClassname(expression, offset);
     }
@@ -285,24 +273,9 @@ public class StatementGenerator {
     }
 
 
-    private Statement convert(Java8Parser.ClassInstanceCreationExpressionContext newExpression) {
+    private Statement convert(Java8Parser.ClassInstanceCreationExpressionContext stmt) {
-        Java8Parser.TypeArgumentsContext genericArgs = null;
+        //TODO
-        if(newExpression.expressionName()!= null)throw new NotImplementedException();
+        throw new NotImplementedException();
-        if(newExpression.typeArgumentsOrDiamond()!= null){
-            if(newExpression.typeArgumentsOrDiamond().typeArguments()!=null){
-                genericArgs = newExpression.typeArgumentsOrDiamond().typeArguments();
-            }
-        }
-        if(newExpression.typeArguments()!= null)throw new NotImplementedException();
-
-        TerminalNode identifier = newExpression.Identifier(0);
-        RefType newClass = (RefType) TypeGenerator.convertTypeName(identifier.getText(),genericArgs,identifier.getSymbol(),reg,generics);
-
-        ArgumentList args = convert(newExpression.argumentList());
-        ArrayList<RefTypeOrTPHOrWildcardOrGeneric> argTypes = args.getArguments().stream()
-        		.map(x -> TypePlaceholder.fresh(newExpression.getStart()))
-        		.collect(Collectors.toCollection(ArrayList::new));
-        return new NewClass(newClass, args, null, argTypes, newExpression.getStart());
     }
 
     private Statement convert(Java8Parser.PreIncrementExpressionContext stmt) {
@@ -433,7 +406,7 @@ public class StatementGenerator {
             throw new NotImplementedException();
         }
         RefTypeOrTPHOrWildcardOrGeneric type;
-        if(declaration.unannTypeOrAuto().unannType() == null){
+        if(declaration.unannTypeOrAuto().unannType().getText().equals(VAR_KEYWORD)){
             type = TypePlaceholder.fresh(declaration.getStart());
         }else{
             type = TypeGenerator.convert(declaration.unannTypeOrAuto().unannType(), reg, generics);
@@ -473,7 +446,7 @@ public class StatementGenerator {
         }
         return (new Assign(new AssignToField(
                 new FieldVar(new This(varDecl.getStart()), name.getText(),
-                        type, varDecl.getStart())),
+                        new Void(varDecl.getStart()), varDecl.getStart())),
                 initValue, name.getSymbol()));
     }
 
@@ -611,10 +584,7 @@ public class StatementGenerator {
         if(expression.equalityExpression() == null){
             return convert(expression.relationalExpression());
         }else{
-            String operator = expression.getChild(1).getText();
+            throw new NotImplementedException();
-            Expression leftSide = convert(expression.equalityExpression());
-            Expression rightSide = convert(expression.relationalExpression());
-            return new BinaryExpr(convertBinaryOperator(operator), TypePlaceholder.fresh(expression.getStart()), leftSide, rightSide, expression.getStart());
         }
     }
 
@@ -650,12 +620,8 @@ public class StatementGenerator {
     			return BinaryExpr.Operator.BIGGERTHAN;
     		}else if(operator.equals(">=")) {
     			return BinaryExpr.Operator.BIGGEREQUAL;
-            } else if(operator.equals("<=")) {
+    		} else if(operator.equals("<=")) {
-                return BinaryExpr.Operator.LESSEQUAL;
+    			return BinaryExpr.Operator.LESSEQUAL;
-    		} else if(operator.equals("==")) {
-                return BinaryExpr.Operator.EQUAL;
-    		} else if(operator.equals("!=")) {
-                return BinaryExpr.Operator.NOTEQUAL;
     		} else {
     			throw new NotImplementedException();
     		}
@@ -779,7 +745,6 @@ public class StatementGenerator {
         if(e.classInstanceCreationExpression_lf_primary() != null){
             throw new NotImplementedException();
         }else if(e.fieldAccess_lf_primary() != null){
-            
             throw new NotImplementedException();
         }else if(e.arrayAccess_lf_primary() != null){
             throw new NotImplementedException();
@@ -788,11 +753,7 @@ public class StatementGenerator {
         }else {
             Java8Parser.MethodInvocation_lf_primaryContext ctxt = e.methodInvocation_lf_primary();
             String methodName = ctxt.Identifier().toString();
-            ArrayList<RefTypeOrTPHOrWildcardOrGeneric> argTypes = ctxt.argumentList().expression().stream()
+            return new MethodCall(TypePlaceholder.fresh(e.getStart()), getReceiver(expr), methodName, convert(ctxt.argumentList()), e.getStart());
-            		.map(x -> TypePlaceholder.fresh(e.getStart()))
-            		.collect(Collectors.toCollection(ArrayList::new));
-            return new MethodCall(TypePlaceholder.fresh(e.getStart()), getReceiver(expr), methodName, 
-            		convert(ctxt.argumentList()), TypePlaceholder.fresh(e.getStart()), argTypes, e.getStart());
         }
     }
 
@@ -838,6 +799,8 @@ public class StatementGenerator {
         if(newExpression.typeArgumentsOrDiamond()!= null){
             if(newExpression.typeArgumentsOrDiamond().typeArguments()!=null){
                 genericArgs = newExpression.typeArgumentsOrDiamond().typeArguments();
+            }else {
+                throw new NotImplementedException();
             }
         }
         if(newExpression.typeArguments()!= null)throw new NotImplementedException();
@@ -846,19 +809,12 @@ public class StatementGenerator {
         RefType newClass = (RefType) TypeGenerator.convertTypeName(identifier.getText(),genericArgs,identifier.getSymbol(),reg,generics);
 
         ArgumentList args = convert(newExpression.argumentList());
-        ArrayList<RefTypeOrTPHOrWildcardOrGeneric> argTypes = args.getArguments().stream()
+        return new NewClass(newClass, args, newExpression.getStart());
-        		.map(x -> TypePlaceholder.fresh(newExpression.getStart()))
-        		.collect(Collectors.toCollection(ArrayList::new));
-        return new NewClass(newClass, args, null, argTypes, newExpression.getStart());
     }
 
     private Expression convert(Java8Parser.LiteralContext literal) {
-        if(literal.IntegerLiteral() != null){
+        if(literal.IntegerLiteral() != null || literal.FloatingPointLiteral()!= null){
-            Number value = Integer.parseInt(literal.IntegerLiteral().getText());
+            Number value = Double.parseDouble(literal.IntegerLiteral().getText());
-            return new Literal(TypePlaceholder.fresh(literal.getStart()),
-                    value, literal.getStart());
-        } else if(literal.FloatingPointLiteral()!= null){
-            Number value = Double.parseDouble(literal.FloatingPointLiteral().getText());
             return new Literal(TypePlaceholder.fresh(literal.getStart()),
                     value, literal.getStart());
         }else if(literal.BooleanLiteral() != null){
@@ -907,12 +863,7 @@ public class StatementGenerator {
         }
 
         ArgumentList argumentList = convert(methodInvocationContext.argumentList());
-        ArrayList<RefTypeOrTPHOrWildcardOrGeneric> argTypes = argumentList.getArguments().stream()
+        MethodCall ret = new MethodCall(TypePlaceholder.fresh(methodInvocationContext.getStart()), getReceiver(receiver), name, argumentList, methodInvocationContext.getStart());
-        		.map(x -> TypePlaceholder.fresh(methodInvocationContext.getStart()))
-        		.collect(Collectors.toCollection(ArrayList::new));
-        MethodCall ret = new MethodCall(TypePlaceholder.fresh(methodInvocationContext.getStart()), 
-        		getReceiver(receiver), name, argumentList, TypePlaceholder.fresh(methodInvocationContext.getStart()),
-        		argTypes, methodInvocationContext.getStart());
         return ret;
     }
 
@@ -936,7 +887,7 @@ public class StatementGenerator {
         for(FormalParameter param : params.getFormalparalist()){
             lambdaLocals.put(param.getName(), param.getType());
         }
-        StatementGenerator lambdaGenerator = new StatementGenerator(reg, generics, fields, lambdaLocals);
+        StatementGenerator lambdaGenerator = new StatementGenerator(reg, generics, lambdaLocals);
 
         Block block;
         if(expression.lambdaBody().expression() != null){

src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/SyntaxTreeGenerator.java

@@ -5,7 +5,6 @@ import de.dhbwstuttgart.exceptions.NotImplementedException;
 import java.lang.ClassNotFoundException;
 
 import de.dhbwstuttgart.exceptions.TypeinferenceException;
-import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.antlr.Java8Parser;
 import de.dhbwstuttgart.parser.scope.GatherNames;
 import de.dhbwstuttgart.parser.scope.GenericsRegistry;
@@ -19,7 +18,6 @@ import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 
 import java.lang.reflect.Modifier;
-import java.net.URL;
 import java.sql.Ref;
 import java.util.*;
 import java.util.stream.Collectors;
@@ -34,9 +32,8 @@ public class SyntaxTreeGenerator{
   private final GenericsRegistry globalGenerics;
   private String pkgName = "";
   Set<JavaClassName> imports = new HashSet();
-  private Map<String, RefTypeOrTPHOrWildcardOrGeneric> fields = new HashMap<>(); //PL 2018-11-01 fields eingefuegt, damit die fields immer die gleiche TPH bekommen
 
-  List<Statement> fieldInitializations = new ArrayList<>(); //PL 2019-10-23: Muss für jede Klasse neu initilisiert werden
+  List<Statement> fieldInitializations = new ArrayList<>();
 
   public SyntaxTreeGenerator(JavaClassRegistry reg, GenericsRegistry globalGenerics){
     //Die Generics müssen während des Bauens des AST erstellt werden,
@@ -75,10 +72,10 @@ public class SyntaxTreeGenerator{
     return ret;
   }
   
-  public SourceFile convert(Java8Parser.CompilationUnitContext ctx, PackageCrawler packageCrawler, ClassLoader classLoader) throws ClassNotFoundException{
+  public SourceFile convert(Java8Parser.CompilationUnitContext ctx, PackageCrawler packageCrawler) throws ClassNotFoundException{
     if(ctx.packageDeclaration()!=null)this.pkgName = convert(ctx.packageDeclaration());
     List<ClassOrInterface> classes = new ArrayList<>();
-    Map<String, Integer> imports = GatherNames.getImports(ctx, packageCrawler, classLoader);
+    Map<String, Integer> imports = GatherNames.getImports(ctx, packageCrawler);
     this.imports = imports.keySet().stream().map(name -> reg.getName(name)).collect(Collectors.toSet());
     for(Java8Parser.TypeDeclarationContext typeDecl : ctx.typeDeclaration()){
       ClassOrInterface newClass;
@@ -124,7 +121,7 @@ public class SyntaxTreeGenerator{
   private Method convert(int modifiers, Java8Parser.MethodHeaderContext header, Java8Parser.MethodBodyContext body,
                          JavaClassName parentClass, RefType superClass, GenericsRegistry localGenerics) {
 
-    StatementGenerator stmtGen = new StatementGenerator(reg, localGenerics, fields, new HashMap<>());
+    StatementGenerator stmtGen = new StatementGenerator(reg, localGenerics, new HashMap<>());
 
     String name = header.methodDeclarator().Identifier().getText();
     GenericDeclarationList gtvDeclarations = new GenericDeclarationList(new ArrayList<>(), header.getStart());
@@ -152,7 +149,7 @@ public class SyntaxTreeGenerator{
       block = stmtGen.convert(body.block(),true);
     }
     if(parentClass.equals(new JavaClassName(name))){
-      return new Constructor(modifiers, name, retType, parameterList, block, gtvDeclarations, header.getStart() /*, fieldInitializations geloescht PL 2018-11-24 */);
+      return new Constructor(modifiers, name, retType, parameterList, block, gtvDeclarations, header.getStart(), fieldInitializations);
     }else{
       return new Method(modifiers, name, retType, parameterList,block, gtvDeclarations, header.getStart());
     }
@@ -160,7 +157,6 @@ public class SyntaxTreeGenerator{
 
   private ClassOrInterface convertClass(Java8Parser.ClassDeclarationContext ctx)  {
     ClassOrInterface newClass;
-    fieldInitializations = new ArrayList<>(); //PL 2019-10-22: muss für jede Klasse neu initilisiert werden
     if(ctx.normalClassDeclaration() != null){
       newClass = convertNormal(ctx.normalClassDeclaration());
     }
@@ -199,19 +195,14 @@ public class SyntaxTreeGenerator{
       superClass = new RefType(ASTFactory.createObjectClass().getClassName(), ctx.getStart());
     }
     List<Field> fielddecl = convertFields(ctx.classBody(), generics);
-    //fieldInitializations = generateFieldInitializations(ctx.classBody(), generics);
+    List<Method> methods = convertMethods(ctx.classBody(), name, superClass, generics);
-    List<Method> methodsAndConstructors = convertMethods(ctx.classBody(), name, superClass, generics);
-    List<Method> methods = new ArrayList<>();
     List<Constructor> konstruktoren = new ArrayList<>();
-    //int noOfMethods = methods.size();
+    for(int i = 0; i<methods.size();i++){
-    for(int i = 0; i < methodsAndConstructors.size(); i++){
+      Method m = methods.get(i);
-      Method m = methodsAndConstructors.get(i);
       if(m instanceof Constructor){
+        methods.remove(i);
         konstruktoren.add((Constructor) m);
       }
-      else {
-    	  methods.add(m);
-      }
     }
     if(konstruktoren.size()<1){//Standardkonstruktor anfügen:
       konstruktoren.add(
@@ -223,39 +214,10 @@ public class SyntaxTreeGenerator{
 
     Boolean isInterface = false;
     List<RefType> implementedInterfaces = convert(ctx.superinterfaces(), generics);
-    
+    return new ClassOrInterface(modifiers, name, fielddecl, methods, konstruktoren, genericClassParameters, superClass,
-    return new ClassOrInterface(modifiers, name, fielddecl, 
-    		Optional.of(this.generatePseudoConstructor(ctx.Identifier().getText(), name, superClass, genericClassParameters, offset)), 
-    		methods, konstruktoren, genericClassParameters, superClass,
             isInterface, implementedInterfaces, offset);
   }
 
-  /*
-  private List<Statement> generateFieldInitializations(Java8Parser.ClassBodyContext classBodyContext, GenericsRegistry generics) {
-    List<Statement> ret = new ArrayList<>();
-    for(Java8Parser.ClassBodyDeclarationContext classMember : classBodyContext.classBodyDeclaration()){
-      if(classMember.classMemberDeclaration() != null){
-        Java8Parser.ClassMemberDeclarationContext classMemberDeclarationContext = classMember.classMemberDeclaration();
-        if(classMemberDeclarationContext.fieldDeclaration() != null
-                && classMemberDeclarationContext.fieldDeclaration().variableDeclaratorList() != null){
-          for(Java8Parser.VariableDeclaratorContext ctx : classMemberDeclarationContext.fieldDeclaration().variableDeclaratorList().variableDeclarator()) {
-            String fieldName = ctx.variableDeclaratorId().Identifier().getText();
-            if(ctx.variableDeclaratorId().dims() != null)throw new NotImplementedException();
-            Token offset = ctx.getStart();
-            RefTypeOrTPHOrWildcardOrGeneric fieldType;
-            for(Field f : fields)
-            AssignToField leftSide = new AssignToField(new FieldVar(new This(offset), fieldName, ));
-            ret.addAll();
-          }
-        }else if(classMemberDeclarationContext.methodDeclaration()!= null){
-          //Do nothing!
-        }
-      }
-    }
-    return ret;
-  }
-*/
-
   private List<RefType> convert(Java8Parser.SuperinterfacesContext ctx, GenericsRegistry generics) {
     if(ctx == null)return new ArrayList<>();
     return convert(ctx.interfaceTypeList(), generics);
@@ -276,17 +238,9 @@ public class SyntaxTreeGenerator{
     RefType classType = ClassOrInterface.generateTypeOfClass(reg.getName(className), classGenerics, offset);
     ParameterList params = new ParameterList(new ArrayList<>(), offset);
     Block block = new Block(new ArrayList<>(), offset);
-    return new Constructor(Modifier.PUBLIC, className, classType, params, block, classGenerics, offset /*, fieldInitializations geloescht PL 2018-11-24 */);
+    return new Constructor(Modifier.PUBLIC, className, classType, params, block, classGenerics, offset, fieldInitializations);
   }
 
-  /* fieldInitializations werden in einem Psedokonstruktor in der abstrakten Syntax gespeichert */
-  private Constructor generatePseudoConstructor(String className, JavaClassName parentClass, RefType superClass, GenericDeclarationList classGenerics, Token offset){
-	    RefType classType = ClassOrInterface.generateTypeOfClass(reg.getName(className), classGenerics, offset);
-	    ParameterList params = new ParameterList(new ArrayList<>(), offset); 
-	    Block block = new Block(new ArrayList<>(fieldInitializations), offset);
-	    return new Constructor(Modifier.PUBLIC, className, classType, params, block, classGenerics, offset /*, fieldInitializations geloescht PL 2018-11-24 */);
-	  }
-
   private RefType convert(Java8Parser.SuperclassContext superclass) {
     if(superclass.classType().classOrInterfaceType() != null){
       throw new NotImplementedException();
@@ -356,19 +310,19 @@ public class SyntaxTreeGenerator{
       modifiers+=(convert(fieldModifierContext));
     }
     RefTypeOrTPHOrWildcardOrGeneric fieldType;
-    if(fieldDeclarationContext.unannTypeOrAuto() != null
+    if(fieldDeclarationContext.unannType() != null){
-            && fieldDeclarationContext.unannTypeOrAuto().unannType() != null){
+      fieldType = TypeGenerator.convert(fieldDeclarationContext.unannType(), reg, generics);
-      fieldType = TypeGenerator.convert(fieldDeclarationContext.unannTypeOrAuto().unannType(), reg, generics);
     }else{
-      fieldType = TypePlaceholder.fresh(fieldDeclarationContext.variableDeclaratorList().getStart()); //PL 2019-12-06: variableDeclaratorList() eingefuegt, um als Token nicht die Modifier zu bekommen
+      fieldType = TypePlaceholder.fresh(fieldDeclarationContext.getStart());
     }
     for(Java8Parser.VariableDeclaratorContext varCtx : fieldDeclarationContext.variableDeclaratorList().variableDeclarator()){
       String fieldName = convert(varCtx.variableDeclaratorId());
-      fields.put(fieldName, fieldType);
       if(varCtx.variableInitializer() != null){
         initializeField(varCtx, fieldType, generics);
       }
-      ret.add(new Field(fieldName,fieldType,modifiers,varCtx.getStart()));
+      else{
+        ret.add(new Field(fieldName,fieldType,modifiers,varCtx.getStart()));
+      }
     }
     return ret;
   }
@@ -379,7 +333,7 @@ public class SyntaxTreeGenerator{
 
   // Initialize a field by creating implicit constructor.
   private void initializeField(Java8Parser.VariableDeclaratorContext ctx, RefTypeOrTPHOrWildcardOrGeneric typeOfField, GenericsRegistry generics){
-    StatementGenerator statementGenerator = new StatementGenerator(reg, generics, fields, new HashMap<>());
+    StatementGenerator statementGenerator = new StatementGenerator(reg, generics, new HashMap<>());
     fieldInitializations.add(statementGenerator.generateFieldAssignment(ctx, typeOfField));
   }
 
@@ -458,7 +412,7 @@ public class SyntaxTreeGenerator{
 
     List<RefType> extendedInterfaces = convert(ctx.extendsInterfaces(), generics);
 
-    return new ClassOrInterface(modifiers, name, fields, Optional.empty(), methods, new ArrayList<>(),
+    return new ClassOrInterface(modifiers, name, fields, methods, new ArrayList<>(),
             genericParams, superClass, true, extendedInterfaces, ctx.getStart());
   }
 
@@ -473,9 +427,6 @@ public class SyntaxTreeGenerator{
     GenericsRegistry ret = new GenericsRegistry(this.globalGenerics);
     ret.putAll(generics);
     if(ctx == null || ctx.typeParameterList() == null)return ret;
-    for(Java8Parser.TypeParameterContext tp : ctx.typeParameterList().typeParameter()){
-      ret.put(tp.Identifier().getText(), new GenericContext(parentClass, parentMethod));
-    }
     for(Java8Parser.TypeParameterContext tp : ctx.typeParameterList().typeParameter()){
       TypeGenerator.convert(tp, parentClass, parentMethod, reg, ret);
     }

src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java

@@ -3,37 +3,31 @@ package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.exceptions.TypeinferenceException;
 import de.dhbwstuttgart.parser.antlr.Java8Parser;
-import de.dhbwstuttgart.parser.antlr.Java8Parser.UnannClassType_lfno_unannClassOrInterfaceTypeContext;
 import de.dhbwstuttgart.parser.scope.GenericsRegistry;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
 import de.dhbwstuttgart.syntaxtree.GenericDeclarationList;
 import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
-import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
 import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
+
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import org.antlr.v4.runtime.Token;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
 public class TypeGenerator {
 
     public static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.UnannClassOrInterfaceTypeContext unannClassOrInterfaceTypeContext, JavaClassRegistry reg, GenericsRegistry generics) {
-        Java8Parser.TypeArgumentsContext arguments=null;
+        Java8Parser.TypeArgumentsContext arguments;
-        /* PL 2019-03-19 auskommentiert ANFANG
         if(unannClassOrInterfaceTypeContext.unannClassType_lfno_unannClassOrInterfaceType() != null){
             arguments = unannClassOrInterfaceTypeContext.unannClassType_lfno_unannClassOrInterfaceType().typeArguments();
         }else{// if(unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType() != null){
             arguments = unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType().unannClassType_lfno_unannClassOrInterfaceType().typeArguments();
         }
-         PL 2019-03-19 auskommentiert ENDE */
         /**
          * Problem sind hier die verschachtelten Typen mit verschachtelten Typargumenten
          * Beispiel: Typ<String>.InnererTyp<Integer>
@@ -41,28 +35,6 @@ public class TypeGenerator {
         String name = unannClassOrInterfaceTypeContext.getText();
         if(name.contains("<")){
             name = name.split("<")[0]; //Der Typ ist alles vor den ersten Argumenten
-            /* Fuer Debug-Zwecke
-            unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType();
-            unannClassOrInterfaceTypeContext.unannClassType_lfno_unannClassOrInterfaceType().getText();
-            //unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType().unannClassType_lfno_unannClassOrInterfaceType().typeArguments();
-            //UnannClassType_lfno_unannClassOrInterfaceTypeContext
-            unannClassOrInterfaceTypeContext.unannClassType_lf_unannClassOrInterfaceType(0);
-            unannClassOrInterfaceTypeContext.unannClassType_lf_unannClassOrInterfaceType(0).getText();
-            unannClassOrInterfaceTypeContext.unannClassType_lf_unannClassOrInterfaceType(1);
-            unannClassOrInterfaceTypeContext.unannClassType_lf_unannClassOrInterfaceType(1).getText();
-            unannClassOrInterfaceTypeContext.unannClassType_lfno_unannClassOrInterfaceType().getText();
-            //unannClassOrInterfaceTypeContext.unannInterfaceType_lf_unannClassOrInterfaceType();
-            //unannClassOrInterfaceTypeContext.unannInterfaceType_lf_unannClassOrInterfaceType(0).getText();
-            //unannClassOrInterfaceTypeContext.unannInterfaceType_lf_unannClassOrInterfaceType(1).getText();
-            //unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType().getText();
-             */
-            int lastElement = new ArrayList<>(unannClassOrInterfaceTypeContext.unannClassType_lf_unannClassOrInterfaceType()).size()-1;
-            if (lastElement >=0) {//qualifizierter Name z.B.: java.util.Vector
-            	arguments = unannClassOrInterfaceTypeContext.unannClassType_lf_unannClassOrInterfaceType(lastElement).typeArguments();
-            }
-            else { //unqualifizierter Name z.B.: Vector
-            	arguments = unannClassOrInterfaceTypeContext.unannClassType_lfno_unannClassOrInterfaceType().typeArguments();
-            }
         }
         return convertTypeName(name, arguments, unannClassOrInterfaceTypeContext.getStart(), reg, generics);
     }
@@ -105,6 +77,7 @@ public class TypeGenerator {
         List<RefTypeOrTPHOrWildcardOrGeneric> bounds = TypeGenerator.convert(typeParameter.typeBound(),reg, generics);
 
         GenericTypeVar ret = new GenericTypeVar(name, bounds, typeParameter.getStart(), typeParameter.getStop());
+        generics.put(name, new GenericContext(parentClass, parentMethod));
         return ret;
     }
 
@@ -119,7 +92,7 @@ public class TypeGenerator {
             return ret;
         }
         if(typeBoundContext.classOrInterfaceType() != null){
-            ret.add(convert(typeBoundContext.classOrInterfaceType(), reg, generics));
+            ret.add(convert(typeBoundContext.classOrInterfaceType()));
             if(typeBoundContext.additionalBound() != null)
                 for(Java8Parser.AdditionalBoundContext addCtx : typeBoundContext.additionalBound()){
                     ret.add(convert(addCtx.interfaceType()));
@@ -130,19 +103,8 @@ public class TypeGenerator {
         }
     }
 
-    private static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.ClassOrInterfaceTypeContext classOrInterfaceTypeContext, JavaClassRegistry reg, GenericsRegistry generics) {
+    private static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.ClassOrInterfaceTypeContext classOrInterfaceTypeContext) {
-        Java8Parser.ClassType_lfno_classOrInterfaceTypeContext ctx = classOrInterfaceTypeContext.classType_lfno_classOrInterfaceType();
+        throw new NotImplementedException();
-        if(ctx.typeArguments() != null &&
-                classOrInterfaceTypeContext.classType_lf_classOrInterfaceType().size() > 0)
-            throw new NotImplementedException();
-        String typeName = ctx.Identifier().toString();
-        Java8Parser.ClassType_lf_classOrInterfaceTypeContext nextCtx = null;
-        for(Java8Parser.ClassType_lf_classOrInterfaceTypeContext forEachCtx : classOrInterfaceTypeContext.classType_lf_classOrInterfaceType()){
-            nextCtx = forEachCtx;
-            typeName += "." + forEachCtx.Identifier().toString();
-        }
-        Java8Parser.TypeArgumentsContext arguments = nextCtx!=null?nextCtx.typeArguments():ctx.typeArguments();
-        return convertTypeName(typeName, arguments, classOrInterfaceTypeContext.getStart(), reg, generics);
     }
 
     private static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.InterfaceTypeContext interfaceTypeContext) {
@@ -152,7 +114,8 @@ public class TypeGenerator {
     public static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.ReferenceTypeContext referenceTypeContext, JavaClassRegistry reg, GenericsRegistry generics) {
         if(referenceTypeContext.classOrInterfaceType() != null){
             if(referenceTypeContext.classOrInterfaceType().classType_lfno_classOrInterfaceType()!= null){
-                return convert(referenceTypeContext.classOrInterfaceType(), reg, generics);//return convertTypeName(referenceTypeContext.getText(), ctx.typeArguments(),referenceTypeContext.getStart(), reg, generics);
+                Java8Parser.ClassType_lfno_classOrInterfaceTypeContext ctx = referenceTypeContext.classOrInterfaceType().classType_lfno_classOrInterfaceType();
+                return convertTypeName(ctx.Identifier().toString(), ctx.typeArguments(),referenceTypeContext.getStart(), reg, generics);
             }else{
                 throw new NotImplementedException();
             }
@@ -161,35 +124,18 @@ public class TypeGenerator {
         }
     }
 
-    public static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.WildcardContext wildcardContext, JavaClassRegistry reg, GenericsRegistry generics) {
-        if(wildcardContext.wildcardBounds() != null){
-            if(wildcardContext.wildcardBounds().getText().substring(0, 7).equals("extends")){
-                return new ExtendsWildcardType(convert(wildcardContext.wildcardBounds().referenceType(), reg, generics), wildcardContext.getStart());
-            }else{
-            	return new SuperWildcardType(convert(wildcardContext.wildcardBounds().referenceType(), reg, generics), wildcardContext.getStart());
-            }
-        }else{
-            throw new NotImplementedException(); //Wildcard ohne Bound
-        }
-    }
-
     public static RefTypeOrTPHOrWildcardOrGeneric convertTypeName(String name, Token offset, JavaClassRegistry reg, GenericsRegistry generics){
         return convertTypeName(name, null, offset, reg, generics);
     }
 
     public static RefTypeOrTPHOrWildcardOrGeneric convertTypeName(
             String name, Java8Parser.TypeArgumentsContext typeArguments, Token offset, JavaClassRegistry reg, GenericsRegistry generics){
-        if(!reg.contains(name)){ //Dann könnte es ein generischer Type oder ein FunN$$-Type sein
+        if(!reg.contains(name)){ //Dann könnte es ein Generische Type sein
             if(generics.contains(name)){
                 return new GenericRefType(name, offset);
             }else{
-            Pattern p = Pattern.compile("Fun(\\d+)[$][$]");
-            Matcher m = p.matcher(name);
-            if (m.matches()) {//es ist FunN$$-Type 
-                return new RefType(new JavaClassName(name), convert(typeArguments, reg, generics), offset);
-            } else {
                 throw new TypeinferenceException("Der Typ "+ name + " ist nicht vorhanden",offset);
-            }}
+            }
         }
         if(typeArguments == null){
             List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
@@ -207,7 +153,7 @@ public class TypeGenerator {
         List<RefTypeOrTPHOrWildcardOrGeneric> ret = new ArrayList<>();
         for(Java8Parser.TypeArgumentContext arg : typeArguments.typeArgumentList().typeArgument()){
             if(arg.wildcard() != null){
-            	ret.add(convert(arg.wildcard(), reg, generics));
+                throw new NotImplementedException();
             }else{
                 ret.add(convert(arg.referenceType(), reg, generics));
             }

src/de/dhbwstuttgart/parser/antlr/Java8.g4

@@ -109,6 +109,7 @@ classOrInterfaceType
 		|	interfaceType_lfno_classOrInterfaceType
 		)
 		(	classType_lf_classOrInterfaceType
+		|	interfaceType_lf_classOrInterfaceType
 		)*
 	;
 
@@ -332,7 +333,7 @@ classMemberDeclaration
 	;
 
 fieldDeclaration
-	:	fieldModifier* unannTypeOrAuto? variableDeclaratorList ';'
+	:	fieldModifier* unannType? variableDeclaratorList ';'
 	;
 
 fieldModifier
@@ -731,7 +732,6 @@ localVariableDeclarationStatement
 
 unannTypeOrAuto
     : unannType
-    | 'var'
     ;
 
 localVariableDeclaration

src/de/dhbwstuttgart/parser/antlr/Java8.tokens

@@ -0,0 +1,205 @@
+ABSTRACT=1
+ASSERT=2
+BOOLEAN=3
+BREAK=4
+BYTE=5
+CASE=6
+CATCH=7
+CHAR=8
+CLASS=9
+CONST=10
+CONTINUE=11
+DEFAULT=12
+DO=13
+DOUBLE=14
+ELSE=15
+ENUM=16
+EXTENDS=17
+FINAL=18
+FINALLY=19
+FLOAT=20
+FOR=21
+IF=22
+GOTO=23
+IMPLEMENTS=24
+IMPORT=25
+INSTANCEOF=26
+INT=27
+INTERFACE=28
+LONG=29
+NATIVE=30
+NEW=31
+PACKAGE=32
+PRIVATE=33
+PROTECTED=34
+PUBLIC=35
+RETURN=36
+SHORT=37
+STATIC=38
+STRICTFP=39
+SUPER=40
+SWITCH=41
+SYNCHRONIZED=42
+THIS=43
+THROW=44
+THROWS=45
+TRANSIENT=46
+TRY=47
+VOID=48
+VOLATILE=49
+WHILE=50
+IntegerLiteral=51
+FloatingPointLiteral=52
+BooleanLiteral=53
+CharacterLiteral=54
+StringLiteral=55
+NullLiteral=56
+LPAREN=57
+RPAREN=58
+LBRACE=59
+RBRACE=60
+LBRACK=61
+RBRACK=62
+SEMI=63
+COMMA=64
+DOT=65
+ASSIGN=66
+GT=67
+LT=68
+BANG=69
+TILDE=70
+QUESTION=71
+COLON=72
+EQUAL=73
+LE=74
+GE=75
+NOTEQUAL=76
+AND=77
+OR=78
+INC=79
+DEC=80
+ADD=81
+SUB=82
+MUL=83
+DIV=84
+BITAND=85
+BITOR=86
+CARET=87
+MOD=88
+ARROW=89
+COLONCOLON=90
+ADD_ASSIGN=91
+SUB_ASSIGN=92
+MUL_ASSIGN=93
+DIV_ASSIGN=94
+AND_ASSIGN=95
+OR_ASSIGN=96
+XOR_ASSIGN=97
+MOD_ASSIGN=98
+LSHIFT_ASSIGN=99
+RSHIFT_ASSIGN=100
+URSHIFT_ASSIGN=101
+Identifier=102
+AT=103
+ELLIPSIS=104
+WS=105
+COMMENT=106
+LINE_COMMENT=107
+'abstract'=1
+'assert'=2
+'boolean'=3
+'break'=4
+'byte'=5
+'case'=6
+'catch'=7
+'char'=8
+'class'=9
+'const'=10
+'continue'=11
+'default'=12
+'do'=13
+'double'=14
+'else'=15
+'enum'=16
+'extends'=17
+'final'=18
+'finally'=19
+'float'=20
+'for'=21
+'if'=22
+'goto'=23
+'implements'=24
+'import'=25
+'instanceof'=26
+'int'=27
+'interface'=28
+'long'=29
+'native'=30
+'new'=31
+'package'=32
+'private'=33
+'protected'=34
+'public'=35
+'return'=36
+'short'=37
+'static'=38
+'strictfp'=39
+'super'=40
+'switch'=41
+'synchronized'=42
+'this'=43
+'throw'=44
+'throws'=45
+'transient'=46
+'try'=47
+'void'=48
+'volatile'=49
+'while'=50
+'null'=56
+'('=57
+')'=58
+'{'=59
+'}'=60
+'['=61
+']'=62
+';'=63
+','=64
+'.'=65
+'='=66
+'>'=67
+'<'=68
+'!'=69
+'~'=70
+'?'=71
+':'=72
+'=='=73
+'<='=74
+'>='=75
+'!='=76
+'&&'=77
+'||'=78
+'++'=79
+'--'=80
+'+'=81
+'-'=82
+'*'=83
+'/'=84
+'&'=85
+'|'=86
+'^'=87
+'%'=88
+'->'=89
+'::'=90
+'+='=91
+'-='=92
+'*='=93
+'/='=94
+'&='=95
+'|='=96
+'^='=97
+'%='=98
+'<<='=99
+'>>='=100
+'>>>='=101
+'@'=103
+'...'=104

src/de/dhbwstuttgart/parser/antlr/Java8Lexer.java

@@ -0,0 +1,591 @@
+// Generated from Java8.g4 by ANTLR 4.7
+package de.dhbwstuttgart.parser.antlr;
+import org.antlr.v4.runtime.Lexer;
+import org.antlr.v4.runtime.CharStream;
+import org.antlr.v4.runtime.Token;
+import org.antlr.v4.runtime.TokenStream;
+import org.antlr.v4.runtime.*;
+import org.antlr.v4.runtime.atn.*;
+import org.antlr.v4.runtime.dfa.DFA;
+import org.antlr.v4.runtime.misc.*;
+
+@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
+public class Java8Lexer extends Lexer {
+	static { RuntimeMetaData.checkVersion("4.7", RuntimeMetaData.VERSION); }
+
+	protected static final DFA[] _decisionToDFA;
+	protected static final PredictionContextCache _sharedContextCache =
+		new PredictionContextCache();
+	public static final int
+		ABSTRACT=1, ASSERT=2, BOOLEAN=3, BREAK=4, BYTE=5, CASE=6, CATCH=7, CHAR=8, 
+		CLASS=9, CONST=10, CONTINUE=11, DEFAULT=12, DO=13, DOUBLE=14, ELSE=15, 
+		ENUM=16, EXTENDS=17, FINAL=18, FINALLY=19, FLOAT=20, FOR=21, IF=22, GOTO=23, 
+		IMPLEMENTS=24, IMPORT=25, INSTANCEOF=26, INT=27, INTERFACE=28, LONG=29, 
+		NATIVE=30, NEW=31, PACKAGE=32, PRIVATE=33, PROTECTED=34, PUBLIC=35, RETURN=36, 
+		SHORT=37, STATIC=38, STRICTFP=39, SUPER=40, SWITCH=41, SYNCHRONIZED=42, 
+		THIS=43, THROW=44, THROWS=45, TRANSIENT=46, TRY=47, VOID=48, VOLATILE=49, 
+		WHILE=50, IntegerLiteral=51, FloatingPointLiteral=52, BooleanLiteral=53, 
+		CharacterLiteral=54, StringLiteral=55, NullLiteral=56, LPAREN=57, RPAREN=58, 
+		LBRACE=59, RBRACE=60, LBRACK=61, RBRACK=62, SEMI=63, COMMA=64, DOT=65, 
+		ASSIGN=66, GT=67, LT=68, BANG=69, TILDE=70, QUESTION=71, COLON=72, EQUAL=73, 
+		LE=74, GE=75, NOTEQUAL=76, AND=77, OR=78, INC=79, DEC=80, ADD=81, SUB=82, 
+		MUL=83, DIV=84, BITAND=85, BITOR=86, CARET=87, MOD=88, ARROW=89, COLONCOLON=90, 
+		ADD_ASSIGN=91, SUB_ASSIGN=92, MUL_ASSIGN=93, DIV_ASSIGN=94, AND_ASSIGN=95, 
+		OR_ASSIGN=96, XOR_ASSIGN=97, MOD_ASSIGN=98, LSHIFT_ASSIGN=99, RSHIFT_ASSIGN=100, 
+		URSHIFT_ASSIGN=101, Identifier=102, AT=103, ELLIPSIS=104, WS=105, COMMENT=106, 
+		LINE_COMMENT=107;
+	public static String[] channelNames = {
+		"DEFAULT_TOKEN_CHANNEL", "HIDDEN"
+	};
+
+	public static String[] modeNames = {
+		"DEFAULT_MODE"
+	};
+
+	public static final String[] ruleNames = {
+		"ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", "CHAR", 
+		"CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", "ENUM", 
+		"EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", "IMPLEMENTS", 
+		"IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", "NEW", "PACKAGE", 
+		"PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", "STATIC", "STRICTFP", 
+		"SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TRANSIENT", 
+		"TRY", "VOID", "VOLATILE", "WHILE", "IntegerLiteral", "DecimalIntegerLiteral", 
+		"HexIntegerLiteral", "OctalIntegerLiteral", "BinaryIntegerLiteral", "IntegerTypeSuffix", 
+		"DecimalNumeral", "Digits", "Digit", "NonZeroDigit", "DigitsAndUnderscores", 
+		"DigitOrUnderscore", "Underscores", "HexNumeral", "HexDigits", "HexDigit", 
+		"HexDigitsAndUnderscores", "HexDigitOrUnderscore", "OctalNumeral", "OctalDigits", 
+		"OctalDigit", "OctalDigitsAndUnderscores", "OctalDigitOrUnderscore", "BinaryNumeral", 
+		"BinaryDigits", "BinaryDigit", "BinaryDigitsAndUnderscores", "BinaryDigitOrUnderscore", 
+		"FloatingPointLiteral", "DecimalFloatingPointLiteral", "ExponentPart", 
+		"ExponentIndicator", "SignedInteger", "Sign", "FloatTypeSuffix", "HexadecimalFloatingPointLiteral", 
+		"HexSignificand", "BinaryExponent", "BinaryExponentIndicator", "BooleanLiteral", 
+		"CharacterLiteral", "SingleCharacter", "StringLiteral", "StringCharacters", 
+		"StringCharacter", "EscapeSequence", "OctalEscape", "ZeroToThree", "UnicodeEscape", 
+		"NullLiteral", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", 
+		"SEMI", "COMMA", "DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", 
+		"COLON", "EQUAL", "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", 
+		"SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET", "MOD", "ARROW", "COLONCOLON", 
+		"ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", 
+		"OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", 
+		"URSHIFT_ASSIGN", "Identifier", "JavaLetter", "JavaLetterOrDigit", "AT", 
+		"ELLIPSIS", "WS", "COMMENT", "LINE_COMMENT"
+	};
+
+	private static final String[] _LITERAL_NAMES = {
+		null, "'abstract'", "'assert'", "'boolean'", "'break'", "'byte'", "'case'", 
+		"'catch'", "'char'", "'class'", "'const'", "'continue'", "'default'", 
+		"'do'", "'double'", "'else'", "'enum'", "'extends'", "'final'", "'finally'", 
+		"'float'", "'for'", "'if'", "'goto'", "'implements'", "'import'", "'instanceof'", 
+		"'int'", "'interface'", "'long'", "'native'", "'new'", "'package'", "'private'", 
+		"'protected'", "'public'", "'return'", "'short'", "'static'", "'strictfp'", 
+		"'super'", "'switch'", "'synchronized'", "'this'", "'throw'", "'throws'", 
+		"'transient'", "'try'", "'void'", "'volatile'", "'while'", null, null, 
+		null, null, null, "'null'", "'('", "')'", "'{'", "'}'", "'['", "']'", 
+		"';'", "','", "'.'", "'='", "'>'", "'<'", "'!'", "'~'", "'?'", "':'", 
+		"'=='", "'<='", "'>='", "'!='", "'&&'", "'||'", "'++'", "'--'", "'+'", 
+		"'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", "'->'", "'::'", "'+='", 
+		"'-='", "'*='", "'/='", "'&='", "'|='", "'^='", "'%='", "'<<='", "'>>='", 
+		"'>>>='", null, "'@'", "'...'"
+	};
+	private static final String[] _SYMBOLIC_NAMES = {
+		null, "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", 
+		"CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", 
+		"ENUM", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", "IMPLEMENTS", 
+		"IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", "NEW", "PACKAGE", 
+		"PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", "STATIC", "STRICTFP", 
+		"SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TRANSIENT", 
+		"TRY", "VOID", "VOLATILE", "WHILE", "IntegerLiteral", "FloatingPointLiteral", 
+		"BooleanLiteral", "CharacterLiteral", "StringLiteral", "NullLiteral", 
+		"LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", "SEMI", "COMMA", 
+		"DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", "COLON", "EQUAL", 
+		"LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", "SUB", "MUL", 
+		"DIV", "BITAND", "BITOR", "CARET", "MOD", "ARROW", "COLONCOLON", "ADD_ASSIGN", 
+		"SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", 
+		"MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", "URSHIFT_ASSIGN", "Identifier", 
+		"AT", "ELLIPSIS", "WS", "COMMENT", "LINE_COMMENT"
+	};
+	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
+
+	/**
+	 * @deprecated Use {@link #VOCABULARY} instead.
+	 */
+	@Deprecated
+	public static final String[] tokenNames;
+	static {
+		tokenNames = new String[_SYMBOLIC_NAMES.length];
+		for (int i = 0; i < tokenNames.length; i++) {
+			tokenNames[i] = VOCABULARY.getLiteralName(i);
+			if (tokenNames[i] == null) {
+				tokenNames[i] = VOCABULARY.getSymbolicName(i);
+			}
+
+			if (tokenNames[i] == null) {
+				tokenNames[i] = "<INVALID>";
+			}
+		}
+	}
+
+	@Override
+	@Deprecated
+	public String[] getTokenNames() {
+		return tokenNames;
+	}
+
+	@Override
+
+	public Vocabulary getVocabulary() {
+		return VOCABULARY;
+	}
+
+
+	public Java8Lexer(CharStream input) {
+		super(input);
+		_interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
+	}
+
+	@Override
+	public String getGrammarFileName() { return "Java8.g4"; }
+
+	@Override
+	public String[] getRuleNames() { return ruleNames; }
+
+	@Override
+	public String getSerializedATN() { return _serializedATN; }
+
+	@Override
+	public String[] getChannelNames() { return channelNames; }
+
+	@Override
+	public String[] getModeNames() { return modeNames; }
+
+	@Override
+	public ATN getATN() { return _ATN; }
+
+	@Override
+	public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
+		switch (ruleIndex) {
+		case 146:
+			return JavaLetter_sempred((RuleContext)_localctx, predIndex);
+		case 147:
+			return JavaLetterOrDigit_sempred((RuleContext)_localctx, predIndex);
+		}
+		return true;
+	}
+	private boolean JavaLetter_sempred(RuleContext _localctx, int predIndex) {
+		switch (predIndex) {
+		case 0:
+			return Character.isJavaIdentifierStart(_input.LA(-1));
+		case 1:
+			return Character.isJavaIdentifierStart(Character.toCodePoint((char)_input.LA(-2), (char)_input.LA(-1)));
+		}
+		return true;
+	}
+	private boolean JavaLetterOrDigit_sempred(RuleContext _localctx, int predIndex) {
+		switch (predIndex) {
+		case 2:
+			return Character.isJavaIdentifierPart(_input.LA(-1));
+		case 3:
+			return Character.isJavaIdentifierPart(Character.toCodePoint((char)_input.LA(-2), (char)_input.LA(-1)));
+		}
+		return true;
+	}
+
+	public static final String _serializedATN =
+		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2m\u0448\b\1\4\2\t"+
+		"\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+
+		"\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
+		"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
+		"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
+		"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
+		",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
+		"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
+		"\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
+		"\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+
+		"\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+
+		"`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+
+		"k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+
+		"w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080"+
+		"\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085"+
+		"\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089"+
+		"\4\u008a\t\u008a\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e"+
+		"\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092\t\u0092"+
+		"\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095\4\u0096\t\u0096\4\u0097"+
+		"\t\u0097\4\u0098\t\u0098\4\u0099\t\u0099\4\u009a\t\u009a\3\2\3\2\3\2\3"+
+		"\2\3\2\3\2\3\2\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4"+
+		"\3\4\3\4\3\4\3\5\3\5\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\7\3\7\3\7\3"+
+		"\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n"+
+		"\3\n\3\13\3\13\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f"+
+		"\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\16\3\16\3\16\3\17\3\17\3\17\3\17\3"+
+		"\17\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3\21\3\21\3\21\3\21\3\21\3\22\3"+
+		"\22\3\22\3\22\3\22\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\23\3\24\3"+
+		"\24\3\24\3\24\3\24\3\24\3\24\3\24\3\25\3\25\3\25\3\25\3\25\3\25\3\26\3"+
+		"\26\3\26\3\26\3\27\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3\31\3"+
+		"\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\32\3\32\3\32\3\32\3\32\3\32\3"+
+		"\32\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\34\3\34\3"+
+		"\34\3\34\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\36\3\36\3"+
+		"\36\3\36\3\36\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3 \3 \3 \3 \3!\3!\3!"+
+		"\3!\3!\3!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3#\3#\3#\3#\3#\3#\3#\3"+
+		"#\3#\3#\3$\3$\3$\3$\3$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3&\3&\3&\3&\3&\3&\3"+
+		"\'\3\'\3\'\3\'\3\'\3\'\3\'\3(\3(\3(\3(\3(\3(\3(\3(\3(\3)\3)\3)\3)\3)\3"+
+		")\3*\3*\3*\3*\3*\3*\3*\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3,\3,\3"+
+		",\3,\3,\3-\3-\3-\3-\3-\3-\3.\3.\3.\3.\3.\3.\3.\3/\3/\3/\3/\3/\3/\3/\3"+
+		"/\3/\3/\3\60\3\60\3\60\3\60\3\61\3\61\3\61\3\61\3\61\3\62\3\62\3\62\3"+
+		"\62\3\62\3\62\3\62\3\62\3\62\3\63\3\63\3\63\3\63\3\63\3\63\3\64\3\64\3"+
+		"\64\3\64\5\64\u028d\n\64\3\65\3\65\5\65\u0291\n\65\3\66\3\66\5\66\u0295"+
+		"\n\66\3\67\3\67\5\67\u0299\n\67\38\38\58\u029d\n8\39\39\3:\3:\3:\5:\u02a4"+
+		"\n:\3:\3:\3:\5:\u02a9\n:\5:\u02ab\n:\3;\3;\5;\u02af\n;\3;\5;\u02b2\n;"+
+		"\3<\3<\5<\u02b6\n<\3=\3=\3>\6>\u02bb\n>\r>\16>\u02bc\3?\3?\5?\u02c1\n"+
+		"?\3@\6@\u02c4\n@\r@\16@\u02c5\3A\3A\3A\3A\3B\3B\5B\u02ce\nB\3B\5B\u02d1"+
+		"\nB\3C\3C\3D\6D\u02d6\nD\rD\16D\u02d7\3E\3E\5E\u02dc\nE\3F\3F\5F\u02e0"+
+		"\nF\3F\3F\3G\3G\5G\u02e6\nG\3G\5G\u02e9\nG\3H\3H\3I\6I\u02ee\nI\rI\16"+
+		"I\u02ef\3J\3J\5J\u02f4\nJ\3K\3K\3K\3K\3L\3L\5L\u02fc\nL\3L\5L\u02ff\n"+
+		"L\3M\3M\3N\6N\u0304\nN\rN\16N\u0305\3O\3O\5O\u030a\nO\3P\3P\5P\u030e\n"+
+		"P\3Q\3Q\3Q\5Q\u0313\nQ\3Q\5Q\u0316\nQ\3Q\5Q\u0319\nQ\3Q\3Q\3Q\5Q\u031e"+
+		"\nQ\3Q\5Q\u0321\nQ\3Q\3Q\3Q\5Q\u0326\nQ\3Q\3Q\3Q\5Q\u032b\nQ\3R\3R\3R"+
+		"\3S\3S\3T\5T\u0333\nT\3T\3T\3U\3U\3V\3V\3W\3W\3W\5W\u033e\nW\3X\3X\5X"+
+		"\u0342\nX\3X\3X\3X\5X\u0347\nX\3X\3X\5X\u034b\nX\3Y\3Y\3Y\3Z\3Z\3[\3["+
+		"\3[\3[\3[\3[\3[\3[\3[\5[\u035b\n[\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\5\\"+
+		"\u0365\n\\\3]\3]\3^\3^\5^\u036b\n^\3^\3^\3_\6_\u0370\n_\r_\16_\u0371\3"+
+		"`\3`\5`\u0376\n`\3a\3a\3a\3a\5a\u037c\na\3b\3b\3b\3b\3b\3b\3b\3b\3b\3"+
+		"b\3b\5b\u0389\nb\3c\3c\3d\3d\3d\3d\3d\3d\3d\3e\3e\3e\3e\3e\3f\3f\3g\3"+
+		"g\3h\3h\3i\3i\3j\3j\3k\3k\3l\3l\3m\3m\3n\3n\3o\3o\3p\3p\3q\3q\3r\3r\3"+
+		"s\3s\3t\3t\3u\3u\3v\3v\3v\3w\3w\3w\3x\3x\3x\3y\3y\3y\3z\3z\3z\3{\3{\3"+
+		"{\3|\3|\3|\3}\3}\3}\3~\3~\3\177\3\177\3\u0080\3\u0080\3\u0081\3\u0081"+
+		"\3\u0082\3\u0082\3\u0083\3\u0083\3\u0084\3\u0084\3\u0085\3\u0085\3\u0086"+
+		"\3\u0086\3\u0086\3\u0087\3\u0087\3\u0087\3\u0088\3\u0088\3\u0088\3\u0089"+
+		"\3\u0089\3\u0089\3\u008a\3\u008a\3\u008a\3\u008b\3\u008b\3\u008b\3\u008c"+
+		"\3\u008c\3\u008c\3\u008d\3\u008d\3\u008d\3\u008e\3\u008e\3\u008e\3\u008f"+
+		"\3\u008f\3\u008f\3\u0090\3\u0090\3\u0090\3\u0090\3\u0091\3\u0091\3\u0091"+
+		"\3\u0091\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092\3\u0093\3\u0093\7\u0093"+
+		"\u040e\n\u0093\f\u0093\16\u0093\u0411\13\u0093\3\u0094\3\u0094\3\u0094"+
+		"\3\u0094\3\u0094\3\u0094\5\u0094\u0419\n\u0094\3\u0095\3\u0095\3\u0095"+
+		"\3\u0095\3\u0095\3\u0095\5\u0095\u0421\n\u0095\3\u0096\3\u0096\3\u0097"+
+		"\3\u0097\3\u0097\3\u0097\3\u0098\6\u0098\u042a\n\u0098\r\u0098\16\u0098"+
+		"\u042b\3\u0098\3\u0098\3\u0099\3\u0099\3\u0099\3\u0099\7\u0099\u0434\n"+
+		"\u0099\f\u0099\16\u0099\u0437\13\u0099\3\u0099\3\u0099\3\u0099\3\u0099"+
+		"\3\u0099\3\u009a\3\u009a\3\u009a\3\u009a\7\u009a\u0442\n\u009a\f\u009a"+
+		"\16\u009a\u0445\13\u009a\3\u009a\3\u009a\3\u0435\2\u009b\3\3\5\4\7\5\t"+
+		"\6\13\7\r\b\17\t\21\n\23\13\25\f\27\r\31\16\33\17\35\20\37\21!\22#\23"+
+		"%\24\'\25)\26+\27-\30/\31\61\32\63\33\65\34\67\359\36;\37= ?!A\"C#E$G"+
+		"%I&K\'M(O)Q*S+U,W-Y.[/]\60_\61a\62c\63e\64g\65i\2k\2m\2o\2q\2s\2u\2w\2"+
+		"y\2{\2}\2\177\2\u0081\2\u0083\2\u0085\2\u0087\2\u0089\2\u008b\2\u008d"+
+		"\2\u008f\2\u0091\2\u0093\2\u0095\2\u0097\2\u0099\2\u009b\2\u009d\2\u009f"+
+		"\66\u00a1\2\u00a3\2\u00a5\2\u00a7\2\u00a9\2\u00ab\2\u00ad\2\u00af\2\u00b1"+
+		"\2\u00b3\2\u00b5\67\u00b78\u00b9\2\u00bb9\u00bd\2\u00bf\2\u00c1\2\u00c3"+
+		"\2\u00c5\2\u00c7\2\u00c9:\u00cb;\u00cd<\u00cf=\u00d1>\u00d3?\u00d5@\u00d7"+
+		"A\u00d9B\u00dbC\u00ddD\u00dfE\u00e1F\u00e3G\u00e5H\u00e7I\u00e9J\u00eb"+
+		"K\u00edL\u00efM\u00f1N\u00f3O\u00f5P\u00f7Q\u00f9R\u00fbS\u00fdT\u00ff"+
+		"U\u0101V\u0103W\u0105X\u0107Y\u0109Z\u010b[\u010d\\\u010f]\u0111^\u0113"+
+		"_\u0115`\u0117a\u0119b\u011bc\u011dd\u011fe\u0121f\u0123g\u0125h\u0127"+
+		"\2\u0129\2\u012bi\u012dj\u012fk\u0131l\u0133m\3\2\30\4\2NNnn\3\2\63;\4"+
+		"\2ZZzz\5\2\62;CHch\3\2\629\4\2DDdd\3\2\62\63\4\2GGgg\4\2--//\6\2FFHHf"+
+		"fhh\4\2RRrr\4\2))^^\4\2$$^^\n\2$$))^^ddhhppttvv\3\2\62\65\6\2&&C\\aac"+
+		"|\4\2\2\u0081\ud802\udc01\3\2\ud802\udc01\3\2\udc02\ue001\7\2&&\62;C\\"+
+		"aac|\5\2\13\f\16\17\"\"\4\2\f\f\17\17\2\u0456\2\3\3\2\2\2\2\5\3\2\2\2"+
+		"\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3"+
+		"\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2"+
+		"\2\2\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2"+
+		"\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63\3\2"+
+		"\2\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2\2\2=\3\2\2\2\2?\3\2"+
+		"\2\2\2A\3\2\2\2\2C\3\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2\2"+
+		"\2M\3\2\2\2\2O\3\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2Y"+
+		"\3\2\2\2\2[\3\2\2\2\2]\3\2\2\2\2_\3\2\2\2\2a\3\2\2\2\2c\3\2\2\2\2e\3\2"+
+		"\2\2\2g\3\2\2\2\2\u009f\3\2\2\2\2\u00b5\3\2\2\2\2\u00b7\3\2\2\2\2\u00bb"+
+		"\3\2\2\2\2\u00c9\3\2\2\2\2\u00cb\3\2\2\2\2\u00cd\3\2\2\2\2\u00cf\3\2\2"+
+		"\2\2\u00d1\3\2\2\2\2\u00d3\3\2\2\2\2\u00d5\3\2\2\2\2\u00d7\3\2\2\2\2\u00d9"+
+		"\3\2\2\2\2\u00db\3\2\2\2\2\u00dd\3\2\2\2\2\u00df\3\2\2\2\2\u00e1\3\2\2"+
+		"\2\2\u00e3\3\2\2\2\2\u00e5\3\2\2\2\2\u00e7\3\2\2\2\2\u00e9\3\2\2\2\2\u00eb"+
+		"\3\2\2\2\2\u00ed\3\2\2\2\2\u00ef\3\2\2\2\2\u00f1\3\2\2\2\2\u00f3\3\2\2"+
+		"\2\2\u00f5\3\2\2\2\2\u00f7\3\2\2\2\2\u00f9\3\2\2\2\2\u00fb\3\2\2\2\2\u00fd"+
+		"\3\2\2\2\2\u00ff\3\2\2\2\2\u0101\3\2\2\2\2\u0103\3\2\2\2\2\u0105\3\2\2"+
+		"\2\2\u0107\3\2\2\2\2\u0109\3\2\2\2\2\u010b\3\2\2\2\2\u010d\3\2\2\2\2\u010f"+
+		"\3\2\2\2\2\u0111\3\2\2\2\2\u0113\3\2\2\2\2\u0115\3\2\2\2\2\u0117\3\2\2"+
+		"\2\2\u0119\3\2\2\2\2\u011b\3\2\2\2\2\u011d\3\2\2\2\2\u011f\3\2\2\2\2\u0121"+
+		"\3\2\2\2\2\u0123\3\2\2\2\2\u0125\3\2\2\2\2\u012b\3\2\2\2\2\u012d\3\2\2"+
+		"\2\2\u012f\3\2\2\2\2\u0131\3\2\2\2\2\u0133\3\2\2\2\3\u0135\3\2\2\2\5\u013e"+
+		"\3\2\2\2\7\u0145\3\2\2\2\t\u014d\3\2\2\2\13\u0153\3\2\2\2\r\u0158\3\2"+
+		"\2\2\17\u015d\3\2\2\2\21\u0163\3\2\2\2\23\u0168\3\2\2\2\25\u016e\3\2\2"+
+		"\2\27\u0174\3\2\2\2\31\u017d\3\2\2\2\33\u0185\3\2\2\2\35\u0188\3\2\2\2"+
+		"\37\u018f\3\2\2\2!\u0194\3\2\2\2#\u0199\3\2\2\2%\u01a1\3\2\2\2\'\u01a7"+
+		"\3\2\2\2)\u01af\3\2\2\2+\u01b5\3\2\2\2-\u01b9\3\2\2\2/\u01bc\3\2\2\2\61"+
+		"\u01c1\3\2\2\2\63\u01cc\3\2\2\2\65\u01d3\3\2\2\2\67\u01de\3\2\2\29\u01e2"+
+		"\3\2\2\2;\u01ec\3\2\2\2=\u01f1\3\2\2\2?\u01f8\3\2\2\2A\u01fc\3\2\2\2C"+
+		"\u0204\3\2\2\2E\u020c\3\2\2\2G\u0216\3\2\2\2I\u021d\3\2\2\2K\u0224\3\2"+
+		"\2\2M\u022a\3\2\2\2O\u0231\3\2\2\2Q\u023a\3\2\2\2S\u0240\3\2\2\2U\u0247"+
+		"\3\2\2\2W\u0254\3\2\2\2Y\u0259\3\2\2\2[\u025f\3\2\2\2]\u0266\3\2\2\2_"+
+		"\u0270\3\2\2\2a\u0274\3\2\2\2c\u0279\3\2\2\2e\u0282\3\2\2\2g\u028c\3\2"+
+		"\2\2i\u028e\3\2\2\2k\u0292\3\2\2\2m\u0296\3\2\2\2o\u029a\3\2\2\2q\u029e"+
+		"\3\2\2\2s\u02aa\3\2\2\2u\u02ac\3\2\2\2w\u02b5\3\2\2\2y\u02b7\3\2\2\2{"+
+		"\u02ba\3\2\2\2}\u02c0\3\2\2\2\177\u02c3\3\2\2\2\u0081\u02c7\3\2\2\2\u0083"+
+		"\u02cb\3\2\2\2\u0085\u02d2\3\2\2\2\u0087\u02d5\3\2\2\2\u0089\u02db\3\2"+
+		"\2\2\u008b\u02dd\3\2\2\2\u008d\u02e3\3\2\2\2\u008f\u02ea\3\2\2\2\u0091"+
+		"\u02ed\3\2\2\2\u0093\u02f3\3\2\2\2\u0095\u02f5\3\2\2\2\u0097\u02f9\3\2"+
+		"\2\2\u0099\u0300\3\2\2\2\u009b\u0303\3\2\2\2\u009d\u0309\3\2\2\2\u009f"+
+		"\u030d\3\2\2\2\u00a1\u032a\3\2\2\2\u00a3\u032c\3\2\2\2\u00a5\u032f\3\2"+
+		"\2\2\u00a7\u0332\3\2\2\2\u00a9\u0336\3\2\2\2\u00ab\u0338\3\2\2\2\u00ad"+
+		"\u033a\3\2\2\2\u00af\u034a\3\2\2\2\u00b1\u034c\3\2\2\2\u00b3\u034f\3\2"+
+		"\2\2\u00b5\u035a\3\2\2\2\u00b7\u0364\3\2\2\2\u00b9\u0366\3\2\2\2\u00bb"+
+		"\u0368\3\2\2\2\u00bd\u036f\3\2\2\2\u00bf\u0375\3\2\2\2\u00c1\u037b\3\2"+
+		"\2\2\u00c3\u0388\3\2\2\2\u00c5\u038a\3\2\2\2\u00c7\u038c\3\2\2\2\u00c9"+
+		"\u0393\3\2\2\2\u00cb\u0398\3\2\2\2\u00cd\u039a\3\2\2\2\u00cf\u039c\3\2"+
+		"\2\2\u00d1\u039e\3\2\2\2\u00d3\u03a0\3\2\2\2\u00d5\u03a2\3\2\2\2\u00d7"+
+		"\u03a4\3\2\2\2\u00d9\u03a6\3\2\2\2\u00db\u03a8\3\2\2\2\u00dd\u03aa\3\2"+
+		"\2\2\u00df\u03ac\3\2\2\2\u00e1\u03ae\3\2\2\2\u00e3\u03b0\3\2\2\2\u00e5"+
+		"\u03b2\3\2\2\2\u00e7\u03b4\3\2\2\2\u00e9\u03b6\3\2\2\2\u00eb\u03b8\3\2"+
+		"\2\2\u00ed\u03bb\3\2\2\2\u00ef\u03be\3\2\2\2\u00f1\u03c1\3\2\2\2\u00f3"+
+		"\u03c4\3\2\2\2\u00f5\u03c7\3\2\2\2\u00f7\u03ca\3\2\2\2\u00f9\u03cd\3\2"+
+		"\2\2\u00fb\u03d0\3\2\2\2\u00fd\u03d2\3\2\2\2\u00ff\u03d4\3\2\2\2\u0101"+
+		"\u03d6\3\2\2\2\u0103\u03d8\3\2\2\2\u0105\u03da\3\2\2\2\u0107\u03dc\3\2"+
+		"\2\2\u0109\u03de\3\2\2\2\u010b\u03e0\3\2\2\2\u010d\u03e3\3\2\2\2\u010f"+
+		"\u03e6\3\2\2\2\u0111\u03e9\3\2\2\2\u0113\u03ec\3\2\2\2\u0115\u03ef\3\2"+
+		"\2\2\u0117\u03f2\3\2\2\2\u0119\u03f5\3\2\2\2\u011b\u03f8\3\2\2\2\u011d"+
+		"\u03fb\3\2\2\2\u011f\u03fe\3\2\2\2\u0121\u0402\3\2\2\2\u0123\u0406\3\2"+
+		"\2\2\u0125\u040b\3\2\2\2\u0127\u0418\3\2\2\2\u0129\u0420\3\2\2\2\u012b"+
+		"\u0422\3\2\2\2\u012d\u0424\3\2\2\2\u012f\u0429\3\2\2\2\u0131\u042f\3\2"+
+		"\2\2\u0133\u043d\3\2\2\2\u0135\u0136\7c\2\2\u0136\u0137\7d\2\2\u0137\u0138"+
+		"\7u\2\2\u0138\u0139\7v\2\2\u0139\u013a\7t\2\2\u013a\u013b\7c\2\2\u013b"+
+		"\u013c\7e\2\2\u013c\u013d\7v\2\2\u013d\4\3\2\2\2\u013e\u013f\7c\2\2\u013f"+
+		"\u0140\7u\2\2\u0140\u0141\7u\2\2\u0141\u0142\7g\2\2\u0142\u0143\7t\2\2"+
+		"\u0143\u0144\7v\2\2\u0144\6\3\2\2\2\u0145\u0146\7d\2\2\u0146\u0147\7q"+
+		"\2\2\u0147\u0148\7q\2\2\u0148\u0149\7n\2\2\u0149\u014a\7g\2\2\u014a\u014b"+
+		"\7c\2\2\u014b\u014c\7p\2\2\u014c\b\3\2\2\2\u014d\u014e\7d\2\2\u014e\u014f"+
+		"\7t\2\2\u014f\u0150\7g\2\2\u0150\u0151\7c\2\2\u0151\u0152\7m\2\2\u0152"+
+		"\n\3\2\2\2\u0153\u0154\7d\2\2\u0154\u0155\7{\2\2\u0155\u0156\7v\2\2\u0156"+
+		"\u0157\7g\2\2\u0157\f\3\2\2\2\u0158\u0159\7e\2\2\u0159\u015a\7c\2\2\u015a"+
+		"\u015b\7u\2\2\u015b\u015c\7g\2\2\u015c\16\3\2\2\2\u015d\u015e\7e\2\2\u015e"+
+		"\u015f\7c\2\2\u015f\u0160\7v\2\2\u0160\u0161\7e\2\2\u0161\u0162\7j\2\2"+
+		"\u0162\20\3\2\2\2\u0163\u0164\7e\2\2\u0164\u0165\7j\2\2\u0165\u0166\7"+
+		"c\2\2\u0166\u0167\7t\2\2\u0167\22\3\2\2\2\u0168\u0169\7e\2\2\u0169\u016a"+
+		"\7n\2\2\u016a\u016b\7c\2\2\u016b\u016c\7u\2\2\u016c\u016d\7u\2\2\u016d"+
+		"\24\3\2\2\2\u016e\u016f\7e\2\2\u016f\u0170\7q\2\2\u0170\u0171\7p\2\2\u0171"+
+		"\u0172\7u\2\2\u0172\u0173\7v\2\2\u0173\26\3\2\2\2\u0174\u0175\7e\2\2\u0175"+
+		"\u0176\7q\2\2\u0176\u0177\7p\2\2\u0177\u0178\7v\2\2\u0178\u0179\7k\2\2"+
+		"\u0179\u017a\7p\2\2\u017a\u017b\7w\2\2\u017b\u017c\7g\2\2\u017c\30\3\2"+
+		"\2\2\u017d\u017e\7f\2\2\u017e\u017f\7g\2\2\u017f\u0180\7h\2\2\u0180\u0181"+
+		"\7c\2\2\u0181\u0182\7w\2\2\u0182\u0183\7n\2\2\u0183\u0184\7v\2\2\u0184"+
+		"\32\3\2\2\2\u0185\u0186\7f\2\2\u0186\u0187\7q\2\2\u0187\34\3\2\2\2\u0188"+
+		"\u0189\7f\2\2\u0189\u018a\7q\2\2\u018a\u018b\7w\2\2\u018b\u018c\7d\2\2"+
+		"\u018c\u018d\7n\2\2\u018d\u018e\7g\2\2\u018e\36\3\2\2\2\u018f\u0190\7"+
+		"g\2\2\u0190\u0191\7n\2\2\u0191\u0192\7u\2\2\u0192\u0193\7g\2\2\u0193 "+
+		"\3\2\2\2\u0194\u0195\7g\2\2\u0195\u0196\7p\2\2\u0196\u0197\7w\2\2\u0197"+
+		"\u0198\7o\2\2\u0198\"\3\2\2\2\u0199\u019a\7g\2\2\u019a\u019b\7z\2\2\u019b"+
+		"\u019c\7v\2\2\u019c\u019d\7g\2\2\u019d\u019e\7p\2\2\u019e\u019f\7f\2\2"+
+		"\u019f\u01a0\7u\2\2\u01a0$\3\2\2\2\u01a1\u01a2\7h\2\2\u01a2\u01a3\7k\2"+
+		"\2\u01a3\u01a4\7p\2\2\u01a4\u01a5\7c\2\2\u01a5\u01a6\7n\2\2\u01a6&\3\2"+
+		"\2\2\u01a7\u01a8\7h\2\2\u01a8\u01a9\7k\2\2\u01a9\u01aa\7p\2\2\u01aa\u01ab"+
+		"\7c\2\2\u01ab\u01ac\7n\2\2\u01ac\u01ad\7n\2\2\u01ad\u01ae\7{\2\2\u01ae"+
+		"(\3\2\2\2\u01af\u01b0\7h\2\2\u01b0\u01b1\7n\2\2\u01b1\u01b2\7q\2\2\u01b2"+
+		"\u01b3\7c\2\2\u01b3\u01b4\7v\2\2\u01b4*\3\2\2\2\u01b5\u01b6\7h\2\2\u01b6"+
+		"\u01b7\7q\2\2\u01b7\u01b8\7t\2\2\u01b8,\3\2\2\2\u01b9\u01ba\7k\2\2\u01ba"+
+		"\u01bb\7h\2\2\u01bb.\3\2\2\2\u01bc\u01bd\7i\2\2\u01bd\u01be\7q\2\2\u01be"+
+		"\u01bf\7v\2\2\u01bf\u01c0\7q\2\2\u01c0\60\3\2\2\2\u01c1\u01c2\7k\2\2\u01c2"+
+		"\u01c3\7o\2\2\u01c3\u01c4\7r\2\2\u01c4\u01c5\7n\2\2\u01c5\u01c6\7g\2\2"+
+		"\u01c6\u01c7\7o\2\2\u01c7\u01c8\7g\2\2\u01c8\u01c9\7p\2\2\u01c9\u01ca"+
+		"\7v\2\2\u01ca\u01cb\7u\2\2\u01cb\62\3\2\2\2\u01cc\u01cd\7k\2\2\u01cd\u01ce"+
+		"\7o\2\2\u01ce\u01cf\7r\2\2\u01cf\u01d0\7q\2\2\u01d0\u01d1\7t\2\2\u01d1"+
+		"\u01d2\7v\2\2\u01d2\64\3\2\2\2\u01d3\u01d4\7k\2\2\u01d4\u01d5\7p\2\2\u01d5"+
+		"\u01d6\7u\2\2\u01d6\u01d7\7v\2\2\u01d7\u01d8\7c\2\2\u01d8\u01d9\7p\2\2"+
+		"\u01d9\u01da\7e\2\2\u01da\u01db\7g\2\2\u01db\u01dc\7q\2\2\u01dc\u01dd"+
+		"\7h\2\2\u01dd\66\3\2\2\2\u01de\u01df\7k\2\2\u01df\u01e0\7p\2\2\u01e0\u01e1"+
+		"\7v\2\2\u01e18\3\2\2\2\u01e2\u01e3\7k\2\2\u01e3\u01e4\7p\2\2\u01e4\u01e5"+
+		"\7v\2\2\u01e5\u01e6\7g\2\2\u01e6\u01e7\7t\2\2\u01e7\u01e8\7h\2\2\u01e8"+
+		"\u01e9\7c\2\2\u01e9\u01ea\7e\2\2\u01ea\u01eb\7g\2\2\u01eb:\3\2\2\2\u01ec"+
+		"\u01ed\7n\2\2\u01ed\u01ee\7q\2\2\u01ee\u01ef\7p\2\2\u01ef\u01f0\7i\2\2"+
+		"\u01f0<\3\2\2\2\u01f1\u01f2\7p\2\2\u01f2\u01f3\7c\2\2\u01f3\u01f4\7v\2"+
+		"\2\u01f4\u01f5\7k\2\2\u01f5\u01f6\7x\2\2\u01f6\u01f7\7g\2\2\u01f7>\3\2"+
+		"\2\2\u01f8\u01f9\7p\2\2\u01f9\u01fa\7g\2\2\u01fa\u01fb\7y\2\2\u01fb@\3"+
+		"\2\2\2\u01fc\u01fd\7r\2\2\u01fd\u01fe\7c\2\2\u01fe\u01ff\7e\2\2\u01ff"+
+		"\u0200\7m\2\2\u0200\u0201\7c\2\2\u0201\u0202\7i\2\2\u0202\u0203\7g\2\2"+
+		"\u0203B\3\2\2\2\u0204\u0205\7r\2\2\u0205\u0206\7t\2\2\u0206\u0207\7k\2"+
+		"\2\u0207\u0208\7x\2\2\u0208\u0209\7c\2\2\u0209\u020a\7v\2\2\u020a\u020b"+
+		"\7g\2\2\u020bD\3\2\2\2\u020c\u020d\7r\2\2\u020d\u020e\7t\2\2\u020e\u020f"+
+		"\7q\2\2\u020f\u0210\7v\2\2\u0210\u0211\7g\2\2\u0211\u0212\7e\2\2\u0212"+
+		"\u0213\7v\2\2\u0213\u0214\7g\2\2\u0214\u0215\7f\2\2\u0215F\3\2\2\2\u0216"+
+		"\u0217\7r\2\2\u0217\u0218\7w\2\2\u0218\u0219\7d\2\2\u0219\u021a\7n\2\2"+
+		"\u021a\u021b\7k\2\2\u021b\u021c\7e\2\2\u021cH\3\2\2\2\u021d\u021e\7t\2"+
+		"\2\u021e\u021f\7g\2\2\u021f\u0220\7v\2\2\u0220\u0221\7w\2\2\u0221\u0222"+
+		"\7t\2\2\u0222\u0223\7p\2\2\u0223J\3\2\2\2\u0224\u0225\7u\2\2\u0225\u0226"+
+		"\7j\2\2\u0226\u0227\7q\2\2\u0227\u0228\7t\2\2\u0228\u0229\7v\2\2\u0229"+
+		"L\3\2\2\2\u022a\u022b\7u\2\2\u022b\u022c\7v\2\2\u022c\u022d\7c\2\2\u022d"+
+		"\u022e\7v\2\2\u022e\u022f\7k\2\2\u022f\u0230\7e\2\2\u0230N\3\2\2\2\u0231"+
+		"\u0232\7u\2\2\u0232\u0233\7v\2\2\u0233\u0234\7t\2\2\u0234\u0235\7k\2\2"+
+		"\u0235\u0236\7e\2\2\u0236\u0237\7v\2\2\u0237\u0238\7h\2\2\u0238\u0239"+
+		"\7r\2\2\u0239P\3\2\2\2\u023a\u023b\7u\2\2\u023b\u023c\7w\2\2\u023c\u023d"+
+		"\7r\2\2\u023d\u023e\7g\2\2\u023e\u023f\7t\2\2\u023fR\3\2\2\2\u0240\u0241"+
+		"\7u\2\2\u0241\u0242\7y\2\2\u0242\u0243\7k\2\2\u0243\u0244\7v\2\2\u0244"+
+		"\u0245\7e\2\2\u0245\u0246\7j\2\2\u0246T\3\2\2\2\u0247\u0248\7u\2\2\u0248"+
+		"\u0249\7{\2\2\u0249\u024a\7p\2\2\u024a\u024b\7e\2\2\u024b\u024c\7j\2\2"+
+		"\u024c\u024d\7t\2\2\u024d\u024e\7q\2\2\u024e\u024f\7p\2\2\u024f\u0250"+
+		"\7k\2\2\u0250\u0251\7|\2\2\u0251\u0252\7g\2\2\u0252\u0253\7f\2\2\u0253"+
+		"V\3\2\2\2\u0254\u0255\7v\2\2\u0255\u0256\7j\2\2\u0256\u0257\7k\2\2\u0257"+
+		"\u0258\7u\2\2\u0258X\3\2\2\2\u0259\u025a\7v\2\2\u025a\u025b\7j\2\2\u025b"+
+		"\u025c\7t\2\2\u025c\u025d\7q\2\2\u025d\u025e\7y\2\2\u025eZ\3\2\2\2\u025f"+
+		"\u0260\7v\2\2\u0260\u0261\7j\2\2\u0261\u0262\7t\2\2\u0262\u0263\7q\2\2"+
+		"\u0263\u0264\7y\2\2\u0264\u0265\7u\2\2\u0265\\\3\2\2\2\u0266\u0267\7v"+
+		"\2\2\u0267\u0268\7t\2\2\u0268\u0269\7c\2\2\u0269\u026a\7p\2\2\u026a\u026b"+
+		"\7u\2\2\u026b\u026c\7k\2\2\u026c\u026d\7g\2\2\u026d\u026e\7p\2\2\u026e"+
+		"\u026f\7v\2\2\u026f^\3\2\2\2\u0270\u0271\7v\2\2\u0271\u0272\7t\2\2\u0272"+
+		"\u0273\7{\2\2\u0273`\3\2\2\2\u0274\u0275\7x\2\2\u0275\u0276\7q\2\2\u0276"+
+		"\u0277\7k\2\2\u0277\u0278\7f\2\2\u0278b\3\2\2\2\u0279\u027a\7x\2\2\u027a"+
+		"\u027b\7q\2\2\u027b\u027c\7n\2\2\u027c\u027d\7c\2\2\u027d\u027e\7v\2\2"+
+		"\u027e\u027f\7k\2\2\u027f\u0280\7n\2\2\u0280\u0281\7g\2\2\u0281d\3\2\2"+
+		"\2\u0282\u0283\7y\2\2\u0283\u0284\7j\2\2\u0284\u0285\7k\2\2\u0285\u0286"+
+		"\7n\2\2\u0286\u0287\7g\2\2\u0287f\3\2\2\2\u0288\u028d\5i\65\2\u0289\u028d"+
+		"\5k\66\2\u028a\u028d\5m\67\2\u028b\u028d\5o8\2\u028c\u0288\3\2\2\2\u028c"+
+		"\u0289\3\2\2\2\u028c\u028a\3\2\2\2\u028c\u028b\3\2\2\2\u028dh\3\2\2\2"+
+		"\u028e\u0290\5s:\2\u028f\u0291\5q9\2\u0290\u028f\3\2\2\2\u0290\u0291\3"+
+		"\2\2\2\u0291j\3\2\2\2\u0292\u0294\5\u0081A\2\u0293\u0295\5q9\2\u0294\u0293"+
+		"\3\2\2\2\u0294\u0295\3\2\2\2\u0295l\3\2\2\2\u0296\u0298\5\u008bF\2\u0297"+
+		"\u0299\5q9\2\u0298\u0297\3\2\2\2\u0298\u0299\3\2\2\2\u0299n\3\2\2\2\u029a"+
+		"\u029c\5\u0095K\2\u029b\u029d\5q9\2\u029c\u029b\3\2\2\2\u029c\u029d\3"+
+		"\2\2\2\u029dp\3\2\2\2\u029e\u029f\t\2\2\2\u029fr\3\2\2\2\u02a0\u02ab\7"+
+		"\62\2\2\u02a1\u02a8\5y=\2\u02a2\u02a4\5u;\2\u02a3\u02a2\3\2\2\2\u02a3"+
+		"\u02a4\3\2\2\2\u02a4\u02a9\3\2\2\2\u02a5\u02a6\5\177@\2\u02a6\u02a7\5"+
+		"u;\2\u02a7\u02a9\3\2\2\2\u02a8\u02a3\3\2\2\2\u02a8\u02a5\3\2\2\2\u02a9"+
+		"\u02ab\3\2\2\2\u02aa\u02a0\3\2\2\2\u02aa\u02a1\3\2\2\2\u02abt\3\2\2\2"+
+		"\u02ac\u02b1\5w<\2\u02ad\u02af\5{>\2\u02ae\u02ad\3\2\2\2\u02ae\u02af\3"+
+		"\2\2\2\u02af\u02b0\3\2\2\2\u02b0\u02b2\5w<\2\u02b1\u02ae\3\2\2\2\u02b1"+
+		"\u02b2\3\2\2\2\u02b2v\3\2\2\2\u02b3\u02b6\7\62\2\2\u02b4\u02b6\5y=\2\u02b5"+
+		"\u02b3\3\2\2\2\u02b5\u02b4\3\2\2\2\u02b6x\3\2\2\2\u02b7\u02b8\t\3\2\2"+
+		"\u02b8z\3\2\2\2\u02b9\u02bb\5}?\2\u02ba\u02b9\3\2\2\2\u02bb\u02bc\3\2"+
+		"\2\2\u02bc\u02ba\3\2\2\2\u02bc\u02bd\3\2\2\2\u02bd|\3\2\2\2\u02be\u02c1"+
+		"\5w<\2\u02bf\u02c1\7a\2\2\u02c0\u02be\3\2\2\2\u02c0\u02bf\3\2\2\2\u02c1"+
+		"~\3\2\2\2\u02c2\u02c4\7a\2\2\u02c3\u02c2\3\2\2\2\u02c4\u02c5\3\2\2\2\u02c5"+
+		"\u02c3\3\2\2\2\u02c5\u02c6\3\2\2\2\u02c6\u0080\3\2\2\2\u02c7\u02c8\7\62"+
+		"\2\2\u02c8\u02c9\t\4\2\2\u02c9\u02ca\5\u0083B\2\u02ca\u0082\3\2\2\2\u02cb"+
+		"\u02d0\5\u0085C\2\u02cc\u02ce\5\u0087D\2\u02cd\u02cc\3\2\2\2\u02cd\u02ce"+
+		"\3\2\2\2\u02ce\u02cf\3\2\2\2\u02cf\u02d1\5\u0085C\2\u02d0\u02cd\3\2\2"+
+		"\2\u02d0\u02d1\3\2\2\2\u02d1\u0084\3\2\2\2\u02d2\u02d3\t\5\2\2\u02d3\u0086"+
+		"\3\2\2\2\u02d4\u02d6\5\u0089E\2\u02d5\u02d4\3\2\2\2\u02d6\u02d7\3\2\2"+
+		"\2\u02d7\u02d5\3\2\2\2\u02d7\u02d8\3\2\2\2\u02d8\u0088\3\2\2\2\u02d9\u02dc"+
+		"\5\u0085C\2\u02da\u02dc\7a\2\2\u02db\u02d9\3\2\2\2\u02db\u02da\3\2\2\2"+
+		"\u02dc\u008a\3\2\2\2\u02dd\u02df\7\62\2\2\u02de\u02e0\5\177@\2\u02df\u02de"+
+		"\3\2\2\2\u02df\u02e0\3\2\2\2\u02e0\u02e1\3\2\2\2\u02e1\u02e2\5\u008dG"+
+		"\2\u02e2\u008c\3\2\2\2\u02e3\u02e8\5\u008fH\2\u02e4\u02e6\5\u0091I\2\u02e5"+
+		"\u02e4\3\2\2\2\u02e5\u02e6\3\2\2\2\u02e6\u02e7\3\2\2\2\u02e7\u02e9\5\u008f"+
+		"H\2\u02e8\u02e5\3\2\2\2\u02e8\u02e9\3\2\2\2\u02e9\u008e\3\2\2\2\u02ea"+
+		"\u02eb\t\6\2\2\u02eb\u0090\3\2\2\2\u02ec\u02ee\5\u0093J\2\u02ed\u02ec"+
+		"\3\2\2\2\u02ee\u02ef\3\2\2\2\u02ef\u02ed\3\2\2\2\u02ef\u02f0\3\2\2\2\u02f0"+
+		"\u0092\3\2\2\2\u02f1\u02f4\5\u008fH\2\u02f2\u02f4\7a\2\2\u02f3\u02f1\3"+
+		"\2\2\2\u02f3\u02f2\3\2\2\2\u02f4\u0094\3\2\2\2\u02f5\u02f6\7\62\2\2\u02f6"+
+		"\u02f7\t\7\2\2\u02f7\u02f8\5\u0097L\2\u02f8\u0096\3\2\2\2\u02f9\u02fe"+
+		"\5\u0099M\2\u02fa\u02fc\5\u009bN\2\u02fb\u02fa\3\2\2\2\u02fb\u02fc\3\2"+
+		"\2\2\u02fc\u02fd\3\2\2\2\u02fd\u02ff\5\u0099M\2\u02fe\u02fb\3\2\2\2\u02fe"+
+		"\u02ff\3\2\2\2\u02ff\u0098\3\2\2\2\u0300\u0301\t\b\2\2\u0301\u009a\3\2"+
+		"\2\2\u0302\u0304\5\u009dO\2\u0303\u0302\3\2\2\2\u0304\u0305\3\2\2\2\u0305"+
+		"\u0303\3\2\2\2\u0305\u0306\3\2\2\2\u0306\u009c\3\2\2\2\u0307\u030a\5\u0099"+
+		"M\2\u0308\u030a\7a\2\2\u0309\u0307\3\2\2\2\u0309\u0308\3\2\2\2\u030a\u009e"+
+		"\3\2\2\2\u030b\u030e\5\u00a1Q\2\u030c\u030e\5\u00adW\2\u030d\u030b\3\2"+
+		"\2\2\u030d\u030c\3\2\2\2\u030e\u00a0\3\2\2\2\u030f\u0310\5u;\2\u0310\u0312"+
+		"\7\60\2\2\u0311\u0313\5u;\2\u0312\u0311\3\2\2\2\u0312\u0313\3\2\2\2\u0313"+
+		"\u0315\3\2\2\2\u0314\u0316\5\u00a3R\2\u0315\u0314\3\2\2\2\u0315\u0316"+
+		"\3\2\2\2\u0316\u0318\3\2\2\2\u0317\u0319\5\u00abV\2\u0318\u0317\3\2\2"+
+		"\2\u0318\u0319\3\2\2\2\u0319\u032b\3\2\2\2\u031a\u031b\7\60\2\2\u031b"+
+		"\u031d\5u;\2\u031c\u031e\5\u00a3R\2\u031d\u031c\3\2\2\2\u031d\u031e\3"+
+		"\2\2\2\u031e\u0320\3\2\2\2\u031f\u0321\5\u00abV\2\u0320\u031f\3\2\2\2"+
+		"\u0320\u0321\3\2\2\2\u0321\u032b\3\2\2\2\u0322\u0323\5u;\2\u0323\u0325"+
+		"\5\u00a3R\2\u0324\u0326\5\u00abV\2\u0325\u0324\3\2\2\2\u0325\u0326\3\2"+
+		"\2\2\u0326\u032b\3\2\2\2\u0327\u0328\5u;\2\u0328\u0329\5\u00abV\2\u0329"+
+		"\u032b\3\2\2\2\u032a\u030f\3\2\2\2\u032a\u031a\3\2\2\2\u032a\u0322\3\2"+
+		"\2\2\u032a\u0327\3\2\2\2\u032b\u00a2\3\2\2\2\u032c\u032d\5\u00a5S\2\u032d"+
+		"\u032e\5\u00a7T\2\u032e\u00a4\3\2\2\2\u032f\u0330\t\t\2\2\u0330\u00a6"+
+		"\3\2\2\2\u0331\u0333\5\u00a9U\2\u0332\u0331\3\2\2\2\u0332\u0333\3\2\2"+
+		"\2\u0333\u0334\3\2\2\2\u0334\u0335\5u;\2\u0335\u00a8\3\2\2\2\u0336\u0337"+
+		"\t\n\2\2\u0337\u00aa\3\2\2\2\u0338\u0339\t\13\2\2\u0339\u00ac\3\2\2\2"+
+		"\u033a\u033b\5\u00afX\2\u033b\u033d\5\u00b1Y\2\u033c\u033e\5\u00abV\2"+
+		"\u033d\u033c\3\2\2\2\u033d\u033e\3\2\2\2\u033e\u00ae\3\2\2\2\u033f\u0341"+
+		"\5\u0081A\2\u0340\u0342\7\60\2\2\u0341\u0340\3\2\2\2\u0341\u0342\3\2\2"+
+		"\2\u0342\u034b\3\2\2\2\u0343\u0344\7\62\2\2\u0344\u0346\t\4\2\2\u0345"+
+		"\u0347\5\u0083B\2\u0346\u0345\3\2\2\2\u0346\u0347\3\2\2\2\u0347\u0348"+
+		"\3\2\2\2\u0348\u0349\7\60\2\2\u0349\u034b\5\u0083B\2\u034a\u033f\3\2\2"+
+		"\2\u034a\u0343\3\2\2\2\u034b\u00b0\3\2\2\2\u034c\u034d\5\u00b3Z\2\u034d"+
+		"\u034e\5\u00a7T\2\u034e\u00b2\3\2\2\2\u034f\u0350\t\f\2\2\u0350\u00b4"+
+		"\3\2\2\2\u0351\u0352\7v\2\2\u0352\u0353\7t\2\2\u0353\u0354\7w\2\2\u0354"+
+		"\u035b\7g\2\2\u0355\u0356\7h\2\2\u0356\u0357\7c\2\2\u0357\u0358\7n\2\2"+
+		"\u0358\u0359\7u\2\2\u0359\u035b\7g\2\2\u035a\u0351\3\2\2\2\u035a\u0355"+
+		"\3\2\2\2\u035b\u00b6\3\2\2\2\u035c\u035d\7)\2\2\u035d\u035e\5\u00b9]\2"+
+		"\u035e\u035f\7)\2\2\u035f\u0365\3\2\2\2\u0360\u0361\7)\2\2\u0361\u0362"+
+		"\5\u00c1a\2\u0362\u0363\7)\2\2\u0363\u0365\3\2\2\2\u0364\u035c\3\2\2\2"+
+		"\u0364\u0360\3\2\2\2\u0365\u00b8\3\2\2\2\u0366\u0367\n\r\2\2\u0367\u00ba"+
+		"\3\2\2\2\u0368\u036a\7$\2\2\u0369\u036b\5\u00bd_\2\u036a\u0369\3\2\2\2"+
+		"\u036a\u036b\3\2\2\2\u036b\u036c\3\2\2\2\u036c\u036d\7$\2\2\u036d\u00bc"+
+		"\3\2\2\2\u036e\u0370\5\u00bf`\2\u036f\u036e\3\2\2\2\u0370\u0371\3\2\2"+
+		"\2\u0371\u036f\3\2\2\2\u0371\u0372\3\2\2\2\u0372\u00be\3\2\2\2\u0373\u0376"+
+		"\n\16\2\2\u0374\u0376\5\u00c1a\2\u0375\u0373\3\2\2\2\u0375\u0374\3\2\2"+
+		"\2\u0376\u00c0\3\2\2\2\u0377\u0378\7^\2\2\u0378\u037c\t\17\2\2\u0379\u037c"+
+		"\5\u00c3b\2\u037a\u037c\5\u00c7d\2\u037b\u0377\3\2\2\2\u037b\u0379\3\2"+
+		"\2\2\u037b\u037a\3\2\2\2\u037c\u00c2\3\2\2\2\u037d\u037e\7^\2\2\u037e"+
+		"\u0389\5\u008fH\2\u037f\u0380\7^\2\2\u0380\u0381\5\u008fH\2\u0381\u0382"+
+		"\5\u008fH\2\u0382\u0389\3\2\2\2\u0383\u0384\7^\2\2\u0384\u0385\5\u00c5"+
+		"c\2\u0385\u0386\5\u008fH\2\u0386\u0387\5\u008fH\2\u0387\u0389\3\2\2\2"+
+		"\u0388\u037d\3\2\2\2\u0388\u037f\3\2\2\2\u0388\u0383\3\2\2\2\u0389\u00c4"+
+		"\3\2\2\2\u038a\u038b\t\20\2\2\u038b\u00c6\3\2\2\2\u038c\u038d\7^\2\2\u038d"+
+		"\u038e\7w\2\2\u038e\u038f\5\u0085C\2\u038f\u0390\5\u0085C\2\u0390\u0391"+
+		"\5\u0085C\2\u0391\u0392\5\u0085C\2\u0392\u00c8\3\2\2\2\u0393\u0394\7p"+
+		"\2\2\u0394\u0395\7w\2\2\u0395\u0396\7n\2\2\u0396\u0397\7n\2\2\u0397\u00ca"+
+		"\3\2\2\2\u0398\u0399\7*\2\2\u0399\u00cc\3\2\2\2\u039a\u039b\7+\2\2\u039b"+
+		"\u00ce\3\2\2\2\u039c\u039d\7}\2\2\u039d\u00d0\3\2\2\2\u039e\u039f\7\177"+
+		"\2\2\u039f\u00d2\3\2\2\2\u03a0\u03a1\7]\2\2\u03a1\u00d4\3\2\2\2\u03a2"+
+		"\u03a3\7_\2\2\u03a3\u00d6\3\2\2\2\u03a4\u03a5\7=\2\2\u03a5\u00d8\3\2\2"+
+		"\2\u03a6\u03a7\7.\2\2\u03a7\u00da\3\2\2\2\u03a8\u03a9\7\60\2\2\u03a9\u00dc"+
+		"\3\2\2\2\u03aa\u03ab\7?\2\2\u03ab\u00de\3\2\2\2\u03ac\u03ad\7@\2\2\u03ad"+
+		"\u00e0\3\2\2\2\u03ae\u03af\7>\2\2\u03af\u00e2\3\2\2\2\u03b0\u03b1\7#\2"+
+		"\2\u03b1\u00e4\3\2\2\2\u03b2\u03b3\7\u0080\2\2\u03b3\u00e6\3\2\2\2\u03b4"+
+		"\u03b5\7A\2\2\u03b5\u00e8\3\2\2\2\u03b6\u03b7\7<\2\2\u03b7\u00ea\3\2\2"+
+		"\2\u03b8\u03b9\7?\2\2\u03b9\u03ba\7?\2\2\u03ba\u00ec\3\2\2\2\u03bb\u03bc"+
+		"\7>\2\2\u03bc\u03bd\7?\2\2\u03bd\u00ee\3\2\2\2\u03be\u03bf\7@\2\2\u03bf"+
+		"\u03c0\7?\2\2\u03c0\u00f0\3\2\2\2\u03c1\u03c2\7#\2\2\u03c2\u03c3\7?\2"+
+		"\2\u03c3\u00f2\3\2\2\2\u03c4\u03c5\7(\2\2\u03c5\u03c6\7(\2\2\u03c6\u00f4"+
+		"\3\2\2\2\u03c7\u03c8\7~\2\2\u03c8\u03c9\7~\2\2\u03c9\u00f6\3\2\2\2\u03ca"+
+		"\u03cb\7-\2\2\u03cb\u03cc\7-\2\2\u03cc\u00f8\3\2\2\2\u03cd\u03ce\7/\2"+
+		"\2\u03ce\u03cf\7/\2\2\u03cf\u00fa\3\2\2\2\u03d0\u03d1\7-\2\2\u03d1\u00fc"+
+		"\3\2\2\2\u03d2\u03d3\7/\2\2\u03d3\u00fe\3\2\2\2\u03d4\u03d5\7,\2\2\u03d5"+
+		"\u0100\3\2\2\2\u03d6\u03d7\7\61\2\2\u03d7\u0102\3\2\2\2\u03d8\u03d9\7"+
+		"(\2\2\u03d9\u0104\3\2\2\2\u03da\u03db\7~\2\2\u03db\u0106\3\2\2\2\u03dc"+
+		"\u03dd\7`\2\2\u03dd\u0108\3\2\2\2\u03de\u03df\7\'\2\2\u03df\u010a\3\2"+
+		"\2\2\u03e0\u03e1\7/\2\2\u03e1\u03e2\7@\2\2\u03e2\u010c\3\2\2\2\u03e3\u03e4"+
+		"\7<\2\2\u03e4\u03e5\7<\2\2\u03e5\u010e\3\2\2\2\u03e6\u03e7\7-\2\2\u03e7"+
+		"\u03e8\7?\2\2\u03e8\u0110\3\2\2\2\u03e9\u03ea\7/\2\2\u03ea\u03eb\7?\2"+
+		"\2\u03eb\u0112\3\2\2\2\u03ec\u03ed\7,\2\2\u03ed\u03ee\7?\2\2\u03ee\u0114"+
+		"\3\2\2\2\u03ef\u03f0\7\61\2\2\u03f0\u03f1\7?\2\2\u03f1\u0116\3\2\2\2\u03f2"+
+		"\u03f3\7(\2\2\u03f3\u03f4\7?\2\2\u03f4\u0118\3\2\2\2\u03f5\u03f6\7~\2"+
+		"\2\u03f6\u03f7\7?\2\2\u03f7\u011a\3\2\2\2\u03f8\u03f9\7`\2\2\u03f9\u03fa"+
+		"\7?\2\2\u03fa\u011c\3\2\2\2\u03fb\u03fc\7\'\2\2\u03fc\u03fd\7?\2\2\u03fd"+
+		"\u011e\3\2\2\2\u03fe\u03ff\7>\2\2\u03ff\u0400\7>\2\2\u0400\u0401\7?\2"+
+		"\2\u0401\u0120\3\2\2\2\u0402\u0403\7@\2\2\u0403\u0404\7@\2\2\u0404\u0405"+
+		"\7?\2\2\u0405\u0122\3\2\2\2\u0406\u0407\7@\2\2\u0407\u0408\7@\2\2\u0408"+
+		"\u0409\7@\2\2\u0409\u040a\7?\2\2\u040a\u0124\3\2\2\2\u040b\u040f\5\u0127"+
+		"\u0094\2\u040c\u040e\5\u0129\u0095\2\u040d\u040c\3\2\2\2\u040e\u0411\3"+
+		"\2\2\2\u040f\u040d\3\2\2\2\u040f\u0410\3\2\2\2\u0410\u0126\3\2\2\2\u0411"+
+		"\u040f\3\2\2\2\u0412\u0419\t\21\2\2\u0413\u0414\n\22\2\2\u0414\u0419\6"+
+		"\u0094\2\2\u0415\u0416\t\23\2\2\u0416\u0417\t\24\2\2\u0417\u0419\6\u0094"+
+		"\3\2\u0418\u0412\3\2\2\2\u0418\u0413\3\2\2\2\u0418\u0415\3\2\2\2\u0419"+
+		"\u0128\3\2\2\2\u041a\u0421\t\25\2\2\u041b\u041c\n\22\2\2\u041c\u0421\6"+
+		"\u0095\4\2\u041d\u041e\t\23\2\2\u041e\u041f\t\24\2\2\u041f\u0421\6\u0095"+
+		"\5\2\u0420\u041a\3\2\2\2\u0420\u041b\3\2\2\2\u0420\u041d\3\2\2\2\u0421"+
+		"\u012a\3\2\2\2\u0422\u0423\7B\2\2\u0423\u012c\3\2\2\2\u0424\u0425\7\60"+
+		"\2\2\u0425\u0426\7\60\2\2\u0426\u0427\7\60\2\2\u0427\u012e\3\2\2\2\u0428"+
+		"\u042a\t\26\2\2\u0429\u0428\3\2\2\2\u042a\u042b\3\2\2\2\u042b\u0429\3"+
+		"\2\2\2\u042b\u042c\3\2\2\2\u042c\u042d\3\2\2\2\u042d\u042e\b\u0098\2\2"+
+		"\u042e\u0130\3\2\2\2\u042f\u0430\7\61\2\2\u0430\u0431\7,\2\2\u0431\u0435"+
+		"\3\2\2\2\u0432\u0434\13\2\2\2\u0433\u0432\3\2\2\2\u0434\u0437\3\2\2\2"+
+		"\u0435\u0436\3\2\2\2\u0435\u0433\3\2\2\2\u0436\u0438\3\2\2\2\u0437\u0435"+
+		"\3\2\2\2\u0438\u0439\7,\2\2\u0439\u043a\7\61\2\2\u043a\u043b\3\2\2\2\u043b"+
+		"\u043c\b\u0099\2\2\u043c\u0132\3\2\2\2\u043d\u043e\7\61\2\2\u043e\u043f"+
+		"\7\61\2\2\u043f\u0443\3\2\2\2\u0440\u0442\n\27\2\2\u0441\u0440\3\2\2\2"+
+		"\u0442\u0445\3\2\2\2\u0443\u0441\3\2\2\2\u0443\u0444\3\2\2\2\u0444\u0446"+
+		"\3\2\2\2\u0445\u0443\3\2\2\2\u0446\u0447\b\u009a\2\2\u0447\u0134\3\2\2"+
+		"\28\2\u028c\u0290\u0294\u0298\u029c\u02a3\u02a8\u02aa\u02ae\u02b1\u02b5"+
+		"\u02bc\u02c0\u02c5\u02cd\u02d0\u02d7\u02db\u02df\u02e5\u02e8\u02ef\u02f3"+
+		"\u02fb\u02fe\u0305\u0309\u030d\u0312\u0315\u0318\u031d\u0320\u0325\u032a"+
+		"\u0332\u033d\u0341\u0346\u034a\u035a\u0364\u036a\u0371\u0375\u037b\u0388"+
+		"\u040f\u0418\u0420\u042b\u0435\u0443\3\b\2\2";
+	public static final ATN _ATN =
+		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
+	static {
+		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
+		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
+			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
+		}
+	}
+}

src/de/dhbwstuttgart/parser/antlr/Java8Lexer.tokens

@@ -0,0 +1,205 @@
+ABSTRACT=1
+ASSERT=2
+BOOLEAN=3
+BREAK=4
+BYTE=5
+CASE=6
+CATCH=7
+CHAR=8
+CLASS=9
+CONST=10
+CONTINUE=11
+DEFAULT=12
+DO=13
+DOUBLE=14
+ELSE=15
+ENUM=16
+EXTENDS=17
+FINAL=18
+FINALLY=19
+FLOAT=20
+FOR=21
+IF=22
+GOTO=23
+IMPLEMENTS=24
+IMPORT=25
+INSTANCEOF=26
+INT=27
+INTERFACE=28
+LONG=29
+NATIVE=30
+NEW=31
+PACKAGE=32
+PRIVATE=33
+PROTECTED=34
+PUBLIC=35
+RETURN=36
+SHORT=37
+STATIC=38
+STRICTFP=39
+SUPER=40
+SWITCH=41
+SYNCHRONIZED=42
+THIS=43
+THROW=44
+THROWS=45
+TRANSIENT=46
+TRY=47
+VOID=48
+VOLATILE=49
+WHILE=50
+IntegerLiteral=51
+FloatingPointLiteral=52
+BooleanLiteral=53
+CharacterLiteral=54
+StringLiteral=55
+NullLiteral=56
+LPAREN=57
+RPAREN=58
+LBRACE=59
+RBRACE=60
+LBRACK=61
+RBRACK=62
+SEMI=63
+COMMA=64
+DOT=65
+ASSIGN=66
+GT=67
+LT=68
+BANG=69
+TILDE=70
+QUESTION=71
+COLON=72
+EQUAL=73
+LE=74
+GE=75
+NOTEQUAL=76
+AND=77
+OR=78
+INC=79
+DEC=80
+ADD=81
+SUB=82
+MUL=83
+DIV=84
+BITAND=85
+BITOR=86
+CARET=87
+MOD=88
+ARROW=89
+COLONCOLON=90
+ADD_ASSIGN=91
+SUB_ASSIGN=92
+MUL_ASSIGN=93
+DIV_ASSIGN=94
+AND_ASSIGN=95
+OR_ASSIGN=96
+XOR_ASSIGN=97
+MOD_ASSIGN=98
+LSHIFT_ASSIGN=99
+RSHIFT_ASSIGN=100
+URSHIFT_ASSIGN=101
+Identifier=102
+AT=103
+ELLIPSIS=104
+WS=105
+COMMENT=106
+LINE_COMMENT=107
+'abstract'=1
+'assert'=2
+'boolean'=3
+'break'=4
+'byte'=5
+'case'=6
+'catch'=7
+'char'=8
+'class'=9
+'const'=10
+'continue'=11
+'default'=12
+'do'=13
+'double'=14
+'else'=15
+'enum'=16
+'extends'=17
+'final'=18
+'finally'=19
+'float'=20
+'for'=21
+'if'=22
+'goto'=23
+'implements'=24
+'import'=25
+'instanceof'=26
+'int'=27
+'interface'=28
+'long'=29
+'native'=30
+'new'=31
+'package'=32
+'private'=33
+'protected'=34
+'public'=35
+'return'=36
+'short'=37
+'static'=38
+'strictfp'=39
+'super'=40
+'switch'=41
+'synchronized'=42
+'this'=43
+'throw'=44
+'throws'=45
+'transient'=46
+'try'=47
+'void'=48
+'volatile'=49
+'while'=50
+'null'=56
+'('=57
+')'=58
+'{'=59
+'}'=60
+'['=61
+']'=62
+';'=63
+','=64
+'.'=65
+'='=66
+'>'=67
+'<'=68
+'!'=69
+'~'=70
+'?'=71
+':'=72
+'=='=73
+'<='=74
+'>='=75
+'!='=76
+'&&'=77
+'||'=78
+'++'=79
+'--'=80
+'+'=81
+'-'=82
+'*'=83
+'/'=84
+'&'=85
+'|'=86
+'^'=87
+'%'=88
+'->'=89
+'::'=90
+'+='=91
+'-='=92
+'*='=93
+'/='=94
+'&='=95
+'|='=96
+'^='=97
+'%='=98
+'<<='=99
+'>>='=100
+'>>>='=101
+'@'=103
+'...'=104

src/de/dhbwstuttgart/parser/scope/GatherNames.java

@@ -1,13 +1,13 @@
 package de.dhbwstuttgart.parser.scope;
 
-import java.net.URL;
+import java.util.ArrayList;
-import java.net.URLClassLoader;
+import java.util.HashMap;
-import java.util.*;
+import java.util.List;
+import java.util.Map;
 
 import de.dhbwstuttgart.parser.antlr.Java8BaseListener;
 import de.dhbwstuttgart.syntaxtree.AbstractASTWalker;
 import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor;
-import org.antlr.v4.runtime.tree.ParseTreeWalker;
 import org.antlr.v4.runtime.tree.TerminalNode;
 
 import de.dhbwstuttgart.environment.PackageCrawler;
@@ -15,7 +15,7 @@ import de.dhbwstuttgart.parser.antlr.Java8Parser;
 
 public class GatherNames {
 
-	  public static Map<String, Integer> getNames(Java8Parser.CompilationUnitContext ctx, PackageCrawler packages, ClassLoader classLoader) throws ClassNotFoundException{
+	  public static Map<String, Integer> getNames(Java8Parser.CompilationUnitContext ctx, PackageCrawler packages) throws ClassNotFoundException{
 		  Map<String, Integer> ret = new HashMap<>();
 	    String pkgName = getPackageName(ctx);
 	    String nameString = "";
@@ -43,7 +43,7 @@ public class GatherNames {
 	      }
 	      else{
 	        if(typeDecl.classDeclaration().normalClassDeclaration() != null){
-	          if(!pkgName.isEmpty()){
+	          if(pkgName != ""){
 	            nameString = pkgName + "." + typeDecl.classDeclaration().normalClassDeclaration().Identifier().toString();
 	          }
 	          else{
@@ -64,12 +64,14 @@ public class GatherNames {
 	        }
 	      }
 	    }
-		  ret.putAll(getImports(ctx, packages, classLoader));
+	    ret.putAll(getImports(ctx, packages));
-		  return ret;
+	    return ret;
 	  }
 	  
-	public static Map<String, Integer> getImports(Java8Parser.CompilationUnitContext ctx, PackageCrawler packages, ClassLoader classLoader) throws ClassNotFoundException {
+
+	  public static Map<String, Integer> getImports(Java8Parser.CompilationUnitContext ctx, PackageCrawler packages) throws ClassNotFoundException {
 		  Map<String, Integer> ret = new HashMap<>();
+	    ClassLoader classLoader = ClassLoader.getSystemClassLoader();
 		  //ret.putAll(packages.getClassNames("java.lang"));
 		  for(Java8Parser.ImportDeclarationContext importDeclCtx : ctx.importDeclaration()){
 	      if(importDeclCtx.singleTypeImportDeclaration() != null){

src/de/dhbwstuttgart/parser/scope/JavaClassName.java

@@ -84,15 +84,7 @@ public class JavaClassName {
 
 	@Override
 	public String toString() {
-		return (packageName!=null ? packageName.toString() + "." : "") + name;
+		return (packageName!=null ? packageName.toString() : "") + name;
-	}
-
-	public String getPackageName() {
-		return (packageName!=null ? packageName.toString() : "");
-	}
-
-	public String getClassName(){
-		return name;
 	}
 }
 
@@ -138,9 +130,6 @@ class PackageName{
 		String ret = "";
 		if(names == null)return "";
 		for(String n : names)ret+=n+".";
-		if (ret != null && ret.length() > 0 && ret.charAt(ret.length() - 1) == '.') {
-			ret = ret.substring(0, ret.length() - 1);
-		}
 		return ret;
 	}
 }

src/de/dhbwstuttgart/sat/CNF/CNF.java

@@ -0,0 +1,8 @@
+package de.dhbwstuttgart.sat.CNF;
+
+public class CNF {
+    /*
+    Baut die CNF Datei.
+    Hier muss man überlegen, in welchem Form die Constraints gebaut werden
+     */
+}

src/de/dhbwstuttgart/sat/CNF/Writer.java

@@ -0,0 +1,12 @@
+package de.dhbwstuttgart.sat.CNF;
+
+import java.io.*;
+
+/**
+ * Schreibt CNFs in eine Datei im DIMACS CNF Format
+ */
+public class Writer {
+    public Writer(FileWriter output){
+
+    }
+}

src/de/dhbwstuttgart/sat/asp/ASPStringConverter.java

@@ -0,0 +1,40 @@
+package de.dhbwstuttgart.sat.asp;
+
+import de.dhbwstuttgart.parser.scope.JavaClassName;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class ASPStringConverter {
+    private static final Map<String, String> replacements = new HashMap<>();
+    static{
+        replacements.put(".", "_DOT_");
+        replacements.put("$", "_DOLLAR_");
+    }
+
+    public static String toConstant(JavaClassName name){
+        return toConstant(name.toString());
+    }
+
+    public static String toConstant(String name){
+        return "c" + replace(name);
+    }
+
+    public static String fromConstant(String s){
+        return unReplace(s).substring(1);
+    }
+
+    private static String replace(String input){
+        for(String toReplace : replacements.keySet()){
+            input = input.replace(toReplace, replacements.get(toReplace));
+        }
+        return input;
+    }
+
+    private static String unReplace(String input){
+        for(String toReplace : replacements.keySet()){
+            input = input.replace(replacements.get(toReplace), toReplace);
+        }
+        return input;
+    }
+}

src/de/dhbwstuttgart/sat/asp/Clingo.java

@@ -0,0 +1,52 @@
+package de.dhbwstuttgart.sat.asp;
+
+
+import org.apache.commons.io.IOUtils;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Clingo {
+    private final List<File> input;
+    private static final List<File> programFiles = new ArrayList<>();
+    static{
+        programFiles.add(new File("/home/janulrich/Sync/HiwiJob/ResearchPapers/MasterarbeitStadelmeier/asp/unifyWithoutWildcards/basis.lp"));
+        programFiles.add(new File("/home/janulrich/Sync/HiwiJob/ResearchPapers/MasterarbeitStadelmeier/asp/unifyWithoutWildcards/finiteclosure.lp"));
+        programFiles.add(new File("/home/janulrich/Sync/HiwiJob/ResearchPapers/MasterarbeitStadelmeier/asp/unifyWithoutWildcards/subst.lp"));
+        programFiles.add(new File("/home/janulrich/Sync/HiwiJob/ResearchPapers/MasterarbeitStadelmeier/asp/unifyWithoutWildcards/reduce.lp"));
+        programFiles.add(new File("/home/janulrich/Sync/HiwiJob/ResearchPapers/MasterarbeitStadelmeier/asp/unifyWithoutWildcards/unify.lp"));
+        programFiles.add(new File("/home/janulrich/Sync/HiwiJob/ResearchPapers/MasterarbeitStadelmeier/asp/unifyWithoutWildcards/adapt.lp"));
+    }
+
+    public Clingo(List<File> inputFiles){
+        this.input = inputFiles;
+    }
+
+    /*
+    TODO: Clingo per Java Wrapper https://stackoverflow.com/questions/3356200/using-java-to-wrap-over-c
+     */
+    public String runClingo() throws IOException, InterruptedException {
+        String pathToClingo =
+                "/home/janulrich/Sync/HiwiJob/ResearchPapers/MasterarbeitStadelmeier/asp/clingo-5.2.1-linux-x86_64/clingo";
+        List<String> commands = new ArrayList<>();
+        commands.add(pathToClingo);
+        //commands.add("--outf=2"); //use JSON-Output
+        commands.add("--outf=1"); //use JSON-Output
+        for(File file : input){
+            commands.add(file.getPath());
+        }
+        commands.addAll(programFiles.stream().map(f->f.getPath()).collect(Collectors.toList()));
+
+        Process clingo = new ProcessBuilder( commands.toArray(new String[0])).start();
+        InputStream output = clingo.getInputStream();
+        clingo.waitFor();
+        String result = IOUtils.toString(output, StandardCharsets.UTF_8);
+        return result;
+    }
+}

src/de/dhbwstuttgart/sat/asp/model/ASPGencayRule.java

@@ -0,0 +1,26 @@
+package de.dhbwstuttgart.sat.asp.model;
+
+public enum ASPGencayRule {
+    ASP_PAIR_EQUALS_NAME("equals"),
+    ASP_PAIR_SMALLER_NAME("sub"),
+    ASP_PAIR_SMALLER_DOT_NAME("subEq"),
+    ASP_PARAMLIST_NAME("paramEq"),
+    ASP_FC_PARAMLIST_NAME("param"),
+    ASP_PARAMLIST_END_POINTER("null"),
+    ASP_TYPE("typeEq"),
+    ASP_FCTYPE("type"),
+    ASP_TYPE_VAR("var"),
+    ASP_GENERIC_VAR("pph"),
+    ASP_PARAMLIST_ORDER("paramOrder");
+
+    private final String text;
+
+    private ASPGencayRule(final String text) {
+        this.text = text;
+    }
+
+    @Override
+    public String toString() {
+        return text;
+    }
+}

src/de/dhbwstuttgart/sat/asp/model/ASPRule.java

@@ -0,0 +1,23 @@
+package de.dhbwstuttgart.sat.asp.model;
+
+public enum ASPRule {
+    ASP_PAIR_EQUALS_NAME("equals"),
+    ASP_PAIR_SMALLER_NAME("smaller"),
+    ASP_PAIR_SMALLER_DOT_NAME("smallerDot"),
+    ASP_PARAMLIST_NAME("param"),
+    ASP_PARAMLIST_END_POINTER("null"),
+    ASP_TYPE("type"),
+    ASP_FCTYPE("typeFC"),
+    ASP_TYPE_VAR("typeVar");
+
+    private final String text;
+
+    private ASPRule(final String text) {
+        this.text = text;
+    }
+
+    @Override
+    public String toString() {
+        return text;
+    }
+}

src/de/dhbwstuttgart/sat/asp/parser/ASPParser.java

@@ -0,0 +1,231 @@
+package de.dhbwstuttgart.sat.asp.parser;
+
+import de.dhbwstuttgart.exceptions.DebugException;
+import de.dhbwstuttgart.exceptions.NotImplementedException;
+import de.dhbwstuttgart.parser.NullToken;
+import de.dhbwstuttgart.parser.scope.JavaClassName;
+import de.dhbwstuttgart.sat.asp.ASPStringConverter;
+import de.dhbwstuttgart.sat.asp.model.ASPRule;
+import de.dhbwstuttgart.sat.asp.parser.antlr.UnifyResultBaseListener;
+import de.dhbwstuttgart.sat.asp.parser.antlr.UnifyResultLexer;
+import de.dhbwstuttgart.sat.asp.parser.antlr.UnifyResultParser;
+import de.dhbwstuttgart.sat.asp.parser.model.ParsedType;
+import de.dhbwstuttgart.syntaxtree.type.*;
+import de.dhbwstuttgart.typeinference.result.*;
+import org.antlr.v4.runtime.CharStreams;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.tree.ParseTreeWalker;
+
+import javax.json.Json;
+import javax.json.JsonArray;
+import javax.json.JsonObject;
+import java.io.StringReader;
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+/**
+ * Ablauf:
+ * - Erst werden alle benötigten Statements eingelesen. Die Pointer bleiben als Strings erhalten
+ * - Anschließend müssen diese wieder zu einem Unify Ergebnis zurückgewandelt werden
+ * - Hier nicht die Typen aus dem unify.model packages verwenden.
+ * TODO: Überlegen welche Informationen noch nach der Unifizierung gebraucht werden
+ *  -> Eigentlich nur die korrekten Namen der Typen und TPHs
+ */
+public class ASPParser extends UnifyResultBaseListener {
+    private Collection<TypePlaceholder> originalTPHs;
+    private ResultSet resultSet;
+    private Map<String, ParsedType> types = new HashMap<>();
+    private Set<String> tphs = new HashSet<>();
+    private Map<String, ParameterListNode> parameterLists = new HashMap<>();
+    private Set<Relation> equalsRelations = new HashSet<>();
+    private Set<Relation> smallerRelations = new HashSet<>();
+
+    /**
+     * Parst clingo output welcher als JSON (option --outf=2) ausgibt
+     * @param toParse
+     * @return
+     */
+    public static ResultSet parse(String toParse, Collection<TypePlaceholder> oldPlaceholders){
+        return new ASPParser(toParse, oldPlaceholders).resultSet;
+    }
+
+    @Override
+    public void enterParameter(UnifyResultParser.ParameterContext ctx) {
+        //Linked List (pointer, Type, nextPointer)
+        List<String> params = parseParameterList(ctx.parameterList());
+        parameterLists.put(params.get(0), new ParameterListNode(params.get(1), params.get(2)));
+    }
+
+    private static class Relation {
+        public final String right;
+        public final String left;
+
+        Relation(String leftType, String rightType){
+            this.left = leftType;
+            this.right = rightType;
+        }
+
+        @Override
+        public int hashCode() {
+            return (left+right).hashCode();
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if(obj instanceof Relation)
+                return (right+left).equals(((Relation) obj).left+((Relation) obj).right);
+            return super.equals(obj);
+        }
+    }
+
+    private List<String> parseParameterList(UnifyResultParser.ParameterListContext ctx){
+        return ctx.value().stream().map(v ->
+                //ASPStringConverter.fromConstant(v.getText())
+                v.getText()
+        ).collect(Collectors.toList());
+    }
+
+    @Override
+    public void enterEquals(UnifyResultParser.EqualsContext ctx) {
+        List<String> parameterList = parseParameterList(ctx.parameterList());
+        if(parameterList.size()<2)throw new DebugException("Fehler in Equals-Regel");
+        String ls = parameterList.get(0);
+        String rs = parameterList.get(1);
+        equalsRelations.add(new Relation(ls, rs));
+
+    }
+
+    @Override
+    public void enterSmaller(UnifyResultParser.SmallerContext ctx) {
+        List<String> parameterList = parseParameterList(ctx.parameterList());
+        if(parameterList.size()<2)throw new DebugException("Fehler in Smaller-Regel");
+        String ls = parameterList.get(0);
+        String rs = parameterList.get(1);
+        smallerRelations.add(new Relation(ls, rs));
+    }
+
+    @Override
+    public void enterTypeVar(UnifyResultParser.TypeVarContext ctx) {
+        List<String> parameterList = parseParameterList(ctx.parameterList());
+        if(parameterList.size()<1)throw new DebugException("Fehler in typeVar-Regel");
+        tphs.add(parameterList.get(0));
+    }
+
+    @Override
+    public void enterType(UnifyResultParser.TypeContext ctx){
+        List<String> parameterList = parseParameterList(ctx.parameterList());
+        if(parameterList.size()<3)throw new DebugException("Fehler in Type-Regel");
+        String name = parameterList.get(0);
+        String typeName = parameterList.get(1);
+        String paramPointer = parameterList.get(2);
+        types.put(name, new ParsedType(typeName, paramPointer));
+    }
+
+    /*
+        private List<String> parsedRule;
+        private List<String> parseRule(String rule){
+            UnifyResultLexer lexer = new UnifyResultLexer(CharStreams.fromString(rule));
+            UnifyResultParser.AspruleContext parseTree = new UnifyResultParser(new CommonTokenStream(lexer)).asprule();
+            parsedRule = new ArrayList<>();
+            new ParseTreeWalker().walk(this, parseTree);
+            return parsedRule;
+        }
+
+        @Override
+        public void enterAsprule(UnifyResultParser.AspruleContext ctx) {
+            super.enterAsprule(ctx);
+            for(int i = 0; i< ctx.getChildCount();i++){
+                parsedRule.add(ctx.getChild(i).getText());
+            }
+        }
+    */
+    private ASPParser(String toParse, Collection<TypePlaceholder> oldPlaceholders){
+        //System.out.println(toParse);
+        this.originalTPHs = oldPlaceholders;
+
+        /*
+        JsonObject jsonResult = Json.createReader(new StringReader(toParse)).readObject();
+        JsonArray results = jsonResult.getJsonArray("Call").getJsonObject(0).
+                getJsonArray("Witnesses").getJsonObject(0).
+                getJsonArray("Value");
+
+        //Im ersten Schritt werden alle Regeln geparst
+        String completeResult = "";
+        for(int i = 0; i<results.size();i++){
+            String aspStatement = results.getString(i);
+            completeResult += aspStatement + " ";
+        }
+        System.out.println(completeResult);
+        */
+        UnifyResultLexer lexer = new UnifyResultLexer(CharStreams.fromString(toParse));
+        UnifyResultParser.AnswerContext parseTree = new UnifyResultParser(new CommonTokenStream(lexer)).answer();
+        new ParseTreeWalker().walk(this, parseTree);
+
+        /*
+        Diese Funktion läuft im folgenden mehrmals über das Result aus dem ASP Programm.
+        Dabei werden Schritt für Schritt die Felder dieser Klasse befüllt die am Schluss das ResultSet ergeben
+        */
+        Set<ResultPair> ret = new HashSet<>();
+        //Zuerst die params und typeVars:
+        //for(String paramPointer : types.values().stream().map(parsedType -> parsedType.params).collect(Collectors.toList())){ }
+
+        //Dann die Equalsdot Statements
+        for(Relation eq : equalsRelations){
+            RefTypeOrTPHOrWildcardOrGeneric lsType = this.getType(eq.left);
+            RefTypeOrTPHOrWildcardOrGeneric rsType = this.getType(eq.right);
+            if(lsType instanceof TypePlaceholder && rsType instanceof RefType)
+                ret.add(new PairTPHequalRefTypeOrWildcardType((TypePlaceholder) lsType, rsType));
+            else if(lsType instanceof TypePlaceholder && rsType instanceof TypePlaceholder)
+                ret.add(new PairTPHEqualTPH((TypePlaceholder)lsType, (TypePlaceholder)rsType));
+            else throw new NotImplementedException();
+        }
+        this.resultSet = new ResultSet(ret);
+    }
+
+    private RefTypeOrTPHOrWildcardOrGeneric getType(String name) {
+        if(tphs.contains(name)){
+            name = ASPStringConverter.fromConstant(name);
+            for(TypePlaceholder tph : originalTPHs){
+                if(tph.getName().equals(name))return tph;
+            }
+            return TypePlaceholder.fresh(new NullToken());
+        }else
+        if(types.containsKey(name)){
+            List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
+            ParsedType t = types.get(name);
+
+            for(String param : getParams(t.params)){
+                params.add(this.getType(param));
+            }
+            return new RefType(new JavaClassName(ASPStringConverter.fromConstant(t.name)), params, new NullToken());
+        }else throw new DebugException("Der Typ " + name + " konnte nicht bestimmt werden");
+    }
+
+    private static class ParameterListNode{
+        final String type;
+        final String nextNode;
+
+        public ParameterListNode(String type, String next) {
+            this.type = type;
+            this.nextNode = next;
+        }
+    }
+
+    private List<String> getParams(String pointer) {
+        List<String> params = new ArrayList<>();
+        while(pointer != null){
+            if(pointer.equals(ASPRule.ASP_PARAMLIST_END_POINTER.toString()))return params;
+            if(!parameterLists.containsKey(pointer))
+                throw new DebugException("Fehler in Ergebnisparsen");
+            //TODO: Fehler in ASP. Die adapt Regel muss erkennen, wenn die Parameterliste auf der linken Seite kürzer ist und diese Rechtzeitig beenden
+            ParameterListNode param = parameterLists.get(pointer);
+            pointer = param.nextNode;
+            params.add(param.type);
+        }
+        return params;
+        //Optional<ASPParameterList> ret = parameterLists.stream().filter(aspParameterList -> aspParameterList.name.equals(rs)).findAny();
+        //return ret.get();
+    }
+}

src/de/dhbwstuttgart/sat/asp/parser/antlr/UnifyResultBaseListener.java

@@ -0,0 +1,159 @@
+// Generated from UnifyResult.g4 by ANTLR 4.7
+package de.dhbwstuttgart.sat.asp.parser.antlr;
+
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.tree.ErrorNode;
+import org.antlr.v4.runtime.tree.TerminalNode;
+
+/**
+ * This class provides an empty implementation of {@link UnifyResultListener},
+ * which can be extended to create a listener which only needs to handle a subset
+ * of the available methods.
+ */
+public class UnifyResultBaseListener implements UnifyResultListener {
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterAnswer(UnifyResultParser.AnswerContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitAnswer(UnifyResultParser.AnswerContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterResultSetRule(UnifyResultParser.ResultSetRuleContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitResultSetRule(UnifyResultParser.ResultSetRuleContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterParameterList(UnifyResultParser.ParameterListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitParameterList(UnifyResultParser.ParameterListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterValue(UnifyResultParser.ValueContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitValue(UnifyResultParser.ValueContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterParameter(UnifyResultParser.ParameterContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitParameter(UnifyResultParser.ParameterContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterEquals(UnifyResultParser.EqualsContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitEquals(UnifyResultParser.EqualsContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterSmaller(UnifyResultParser.SmallerContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitSmaller(UnifyResultParser.SmallerContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTypeVar(UnifyResultParser.TypeVarContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTypeVar(UnifyResultParser.TypeVarContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterType(UnifyResultParser.TypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitType(UnifyResultParser.TypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterOtherRule(UnifyResultParser.OtherRuleContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitOtherRule(UnifyResultParser.OtherRuleContext ctx) { }
+
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterEveryRule(ParserRuleContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitEveryRule(ParserRuleContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void visitTerminal(TerminalNode node) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void visitErrorNode(ErrorNode node) { }
+}

src/de/dhbwstuttgart/sat/asp/parser/antlr/UnifyResultLexer.java

@@ -0,0 +1,134 @@
+// Generated from UnifyResult.g4 by ANTLR 4.7
+package de.dhbwstuttgart.sat.asp.parser.antlr;
+import org.antlr.v4.runtime.Lexer;
+import org.antlr.v4.runtime.CharStream;
+import org.antlr.v4.runtime.Token;
+import org.antlr.v4.runtime.TokenStream;
+import org.antlr.v4.runtime.*;
+import org.antlr.v4.runtime.atn.*;
+import org.antlr.v4.runtime.dfa.DFA;
+import org.antlr.v4.runtime.misc.*;
+
+@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
+public class UnifyResultLexer extends Lexer {
+	static { RuntimeMetaData.checkVersion("4.7", RuntimeMetaData.VERSION); }
+
+	protected static final DFA[] _decisionToDFA;
+	protected static final PredictionContextCache _sharedContextCache =
+		new PredictionContextCache();
+	public static final int
+		T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, PARAMLIST_NAME=6, EQUALS_NAME=7, 
+		SMALLER_NAME=8, TYPEVAR_NAME=9, TYPE_NAME=10, NAME=11, WS=12, LINE_COMMENT=13;
+	public static String[] channelNames = {
+		"DEFAULT_TOKEN_CHANNEL", "HIDDEN"
+	};
+
+	public static String[] modeNames = {
+		"DEFAULT_MODE"
+	};
+
+	public static final String[] ruleNames = {
+		"T__0", "T__1", "T__2", "T__3", "T__4", "PARAMLIST_NAME", "EQUALS_NAME", 
+		"SMALLER_NAME", "TYPEVAR_NAME", "TYPE_NAME", "NAME", "WS", "LINE_COMMENT"
+	};
+
+	private static final String[] _LITERAL_NAMES = {
+		null, "'ANSWER'", "'.'", "'('", "','", "')'", "'param'", "'equals'", "'smaller'", 
+		"'typeVar'", "'type'"
+	};
+	private static final String[] _SYMBOLIC_NAMES = {
+		null, null, null, null, null, null, "PARAMLIST_NAME", "EQUALS_NAME", "SMALLER_NAME", 
+		"TYPEVAR_NAME", "TYPE_NAME", "NAME", "WS", "LINE_COMMENT"
+	};
+	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
+
+	/**
+	 * @deprecated Use {@link #VOCABULARY} instead.
+	 */
+	@Deprecated
+	public static final String[] tokenNames;
+	static {
+		tokenNames = new String[_SYMBOLIC_NAMES.length];
+		for (int i = 0; i < tokenNames.length; i++) {
+			tokenNames[i] = VOCABULARY.getLiteralName(i);
+			if (tokenNames[i] == null) {
+				tokenNames[i] = VOCABULARY.getSymbolicName(i);
+			}
+
+			if (tokenNames[i] == null) {
+				tokenNames[i] = "<INVALID>";
+			}
+		}
+	}
+
+	@Override
+	@Deprecated
+	public String[] getTokenNames() {
+		return tokenNames;
+	}
+
+	@Override
+
+	public Vocabulary getVocabulary() {
+		return VOCABULARY;
+	}
+
+
+	public UnifyResultLexer(CharStream input) {
+		super(input);
+		_interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
+	}
+
+	@Override
+	public String getGrammarFileName() { return "UnifyResult.g4"; }
+
+	@Override
+	public String[] getRuleNames() { return ruleNames; }
+
+	@Override
+	public String getSerializedATN() { return _serializedATN; }
+
+	@Override
+	public String[] getChannelNames() { return channelNames; }
+
+	@Override
+	public String[] getModeNames() { return modeNames; }
+
+	@Override
+	public ATN getATN() { return _ATN; }
+
+	public static final String _serializedATN =
+		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\17c\b\1\4\2\t\2\4"+
+		"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
+		"\13\4\f\t\f\4\r\t\r\4\16\t\16\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\3\3\3\3\4"+
+		"\3\4\3\5\3\5\3\6\3\6\3\7\3\7\3\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\3"+
+		"\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\13"+
+		"\3\13\3\13\3\13\3\13\3\f\6\fP\n\f\r\f\16\fQ\3\r\6\rU\n\r\r\r\16\rV\3\r"+
+		"\3\r\3\16\3\16\7\16]\n\16\f\16\16\16`\13\16\3\16\3\16\2\2\17\3\3\5\4\7"+
+		"\5\t\6\13\7\r\b\17\t\21\n\23\13\25\f\27\r\31\16\33\17\3\2\5\6\2\62;C\\"+
+		"aac|\5\2\13\f\16\17\"\"\4\2\f\f\17\17\2e\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3"+
+		"\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2"+
+		"\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\3\35"+
+		"\3\2\2\2\5$\3\2\2\2\7&\3\2\2\2\t(\3\2\2\2\13*\3\2\2\2\r,\3\2\2\2\17\62"+
+		"\3\2\2\2\219\3\2\2\2\23A\3\2\2\2\25I\3\2\2\2\27O\3\2\2\2\31T\3\2\2\2\33"+
+		"Z\3\2\2\2\35\36\7C\2\2\36\37\7P\2\2\37 \7U\2\2 !\7Y\2\2!\"\7G\2\2\"#\7"+
+		"T\2\2#\4\3\2\2\2$%\7\60\2\2%\6\3\2\2\2&\'\7*\2\2\'\b\3\2\2\2()\7.\2\2"+
+		")\n\3\2\2\2*+\7+\2\2+\f\3\2\2\2,-\7r\2\2-.\7c\2\2./\7t\2\2/\60\7c\2\2"+
+		"\60\61\7o\2\2\61\16\3\2\2\2\62\63\7g\2\2\63\64\7s\2\2\64\65\7w\2\2\65"+
+		"\66\7c\2\2\66\67\7n\2\2\678\7u\2\28\20\3\2\2\29:\7u\2\2:;\7o\2\2;<\7c"+
+		"\2\2<=\7n\2\2=>\7n\2\2>?\7g\2\2?@\7t\2\2@\22\3\2\2\2AB\7v\2\2BC\7{\2\2"+
+		"CD\7r\2\2DE\7g\2\2EF\7X\2\2FG\7c\2\2GH\7t\2\2H\24\3\2\2\2IJ\7v\2\2JK\7"+
+		"{\2\2KL\7r\2\2LM\7g\2\2M\26\3\2\2\2NP\t\2\2\2ON\3\2\2\2PQ\3\2\2\2QO\3"+
+		"\2\2\2QR\3\2\2\2R\30\3\2\2\2SU\t\3\2\2TS\3\2\2\2UV\3\2\2\2VT\3\2\2\2V"+
+		"W\3\2\2\2WX\3\2\2\2XY\b\r\2\2Y\32\3\2\2\2Z^\7\'\2\2[]\n\4\2\2\\[\3\2\2"+
+		"\2]`\3\2\2\2^\\\3\2\2\2^_\3\2\2\2_a\3\2\2\2`^\3\2\2\2ab\b\16\2\2b\34\3"+
+		"\2\2\2\6\2QV^\3\b\2\2";
+	public static final ATN _ATN =
+		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
+	static {
+		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
+		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
+			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
+		}
+	}
+}

src/de/dhbwstuttgart/sat/asp/parser/antlr/UnifyResultListener.java

@@ -0,0 +1,110 @@
+// Generated from UnifyResult.g4 by ANTLR 4.7
+package de.dhbwstuttgart.sat.asp.parser.antlr;
+import org.antlr.v4.runtime.tree.ParseTreeListener;
+
+/**
+ * This interface defines a complete listener for a parse tree produced by
+ * {@link UnifyResultParser}.
+ */
+public interface UnifyResultListener extends ParseTreeListener {
+	/**
+	 * Enter a parse tree produced by {@link UnifyResultParser#answer}.
+	 * @param ctx the parse tree
+	 */
+	void enterAnswer(UnifyResultParser.AnswerContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link UnifyResultParser#answer}.
+	 * @param ctx the parse tree
+	 */
+	void exitAnswer(UnifyResultParser.AnswerContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link UnifyResultParser#resultSetRule}.
+	 * @param ctx the parse tree
+	 */
+	void enterResultSetRule(UnifyResultParser.ResultSetRuleContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link UnifyResultParser#resultSetRule}.
+	 * @param ctx the parse tree
+	 */
+	void exitResultSetRule(UnifyResultParser.ResultSetRuleContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link UnifyResultParser#parameterList}.
+	 * @param ctx the parse tree
+	 */
+	void enterParameterList(UnifyResultParser.ParameterListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link UnifyResultParser#parameterList}.
+	 * @param ctx the parse tree
+	 */
+	void exitParameterList(UnifyResultParser.ParameterListContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link UnifyResultParser#value}.
+	 * @param ctx the parse tree
+	 */
+	void enterValue(UnifyResultParser.ValueContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link UnifyResultParser#value}.
+	 * @param ctx the parse tree
+	 */
+	void exitValue(UnifyResultParser.ValueContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link UnifyResultParser#parameter}.
+	 * @param ctx the parse tree
+	 */
+	void enterParameter(UnifyResultParser.ParameterContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link UnifyResultParser#parameter}.
+	 * @param ctx the parse tree
+	 */
+	void exitParameter(UnifyResultParser.ParameterContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link UnifyResultParser#equals}.
+	 * @param ctx the parse tree
+	 */
+	void enterEquals(UnifyResultParser.EqualsContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link UnifyResultParser#equals}.
+	 * @param ctx the parse tree
+	 */
+	void exitEquals(UnifyResultParser.EqualsContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link UnifyResultParser#smaller}.
+	 * @param ctx the parse tree
+	 */
+	void enterSmaller(UnifyResultParser.SmallerContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link UnifyResultParser#smaller}.
+	 * @param ctx the parse tree
+	 */
+	void exitSmaller(UnifyResultParser.SmallerContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link UnifyResultParser#typeVar}.
+	 * @param ctx the parse tree
+	 */
+	void enterTypeVar(UnifyResultParser.TypeVarContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link UnifyResultParser#typeVar}.
+	 * @param ctx the parse tree
+	 */
+	void exitTypeVar(UnifyResultParser.TypeVarContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link UnifyResultParser#type}.
+	 * @param ctx the parse tree
+	 */
+	void enterType(UnifyResultParser.TypeContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link UnifyResultParser#type}.
+	 * @param ctx the parse tree
+	 */
+	void exitType(UnifyResultParser.TypeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link UnifyResultParser#otherRule}.
+	 * @param ctx the parse tree
+	 */
+	void enterOtherRule(UnifyResultParser.OtherRuleContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link UnifyResultParser#otherRule}.
+	 * @param ctx the parse tree
+	 */
+	void exitOtherRule(UnifyResultParser.OtherRuleContext ctx);
+}

src/de/dhbwstuttgart/sat/asp/parser/antlr/UnifyResultParser.java

@@ -0,0 +1,639 @@
+// Generated from UnifyResult.g4 by ANTLR 4.7
+package de.dhbwstuttgart.sat.asp.parser.antlr;
+import org.antlr.v4.runtime.atn.*;
+import org.antlr.v4.runtime.dfa.DFA;
+import org.antlr.v4.runtime.*;
+import org.antlr.v4.runtime.misc.*;
+import org.antlr.v4.runtime.tree.*;
+import java.util.List;
+import java.util.Iterator;
+import java.util.ArrayList;
+
+@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
+public class UnifyResultParser extends Parser {
+	static { RuntimeMetaData.checkVersion("4.7", RuntimeMetaData.VERSION); }
+
+	protected static final DFA[] _decisionToDFA;
+	protected static final PredictionContextCache _sharedContextCache =
+		new PredictionContextCache();
+	public static final int
+		T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, PARAMLIST_NAME=6, EQUALS_NAME=7, 
+		SMALLER_NAME=8, TYPEVAR_NAME=9, TYPE_NAME=10, NAME=11, WS=12, LINE_COMMENT=13;
+	public static final int
+		RULE_answer = 0, RULE_resultSetRule = 1, RULE_parameterList = 2, RULE_value = 3, 
+		RULE_parameter = 4, RULE_equals = 5, RULE_smaller = 6, RULE_typeVar = 7, 
+		RULE_type = 8, RULE_otherRule = 9;
+	public static final String[] ruleNames = {
+		"answer", "resultSetRule", "parameterList", "value", "parameter", "equals", 
+		"smaller", "typeVar", "type", "otherRule"
+	};
+
+	private static final String[] _LITERAL_NAMES = {
+		null, "'ANSWER'", "'.'", "'('", "','", "')'", "'param'", "'equals'", "'smaller'", 
+		"'typeVar'", "'type'"
+	};
+	private static final String[] _SYMBOLIC_NAMES = {
+		null, null, null, null, null, null, "PARAMLIST_NAME", "EQUALS_NAME", "SMALLER_NAME", 
+		"TYPEVAR_NAME", "TYPE_NAME", "NAME", "WS", "LINE_COMMENT"
+	};
+	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
+
+	/**
+	 * @deprecated Use {@link #VOCABULARY} instead.
+	 */
+	@Deprecated
+	public static final String[] tokenNames;
+	static {
+		tokenNames = new String[_SYMBOLIC_NAMES.length];
+		for (int i = 0; i < tokenNames.length; i++) {
+			tokenNames[i] = VOCABULARY.getLiteralName(i);
+			if (tokenNames[i] == null) {
+				tokenNames[i] = VOCABULARY.getSymbolicName(i);
+			}
+
+			if (tokenNames[i] == null) {
+				tokenNames[i] = "<INVALID>";
+			}
+		}
+	}
+
+	@Override
+	@Deprecated
+	public String[] getTokenNames() {
+		return tokenNames;
+	}
+
+	@Override
+
+	public Vocabulary getVocabulary() {
+		return VOCABULARY;
+	}
+
+	@Override
+	public String getGrammarFileName() { return "UnifyResult.g4"; }
+
+	@Override
+	public String[] getRuleNames() { return ruleNames; }
+
+	@Override
+	public String getSerializedATN() { return _serializedATN; }
+
+	@Override
+	public ATN getATN() { return _ATN; }
+
+	public UnifyResultParser(TokenStream input) {
+		super(input);
+		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
+	}
+	public static class AnswerContext extends ParserRuleContext {
+		public List<ResultSetRuleContext> resultSetRule() {
+			return getRuleContexts(ResultSetRuleContext.class);
+		}
+		public ResultSetRuleContext resultSetRule(int i) {
+			return getRuleContext(ResultSetRuleContext.class,i);
+		}
+		public AnswerContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_answer; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).enterAnswer(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).exitAnswer(this);
+		}
+	}
+
+	public final AnswerContext answer() throws RecognitionException {
+		AnswerContext _localctx = new AnswerContext(_ctx, getState());
+		enterRule(_localctx, 0, RULE_answer);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(20);
+			match(T__0);
+			setState(26);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PARAMLIST_NAME) | (1L << EQUALS_NAME) | (1L << SMALLER_NAME) | (1L << TYPEVAR_NAME) | (1L << TYPE_NAME) | (1L << NAME))) != 0)) {
+				{
+				{
+				setState(21);
+				resultSetRule();
+				setState(22);
+				match(T__1);
+				}
+				}
+				setState(28);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ResultSetRuleContext extends ParserRuleContext {
+		public ParameterContext parameter() {
+			return getRuleContext(ParameterContext.class,0);
+		}
+		public EqualsContext equals() {
+			return getRuleContext(EqualsContext.class,0);
+		}
+		public SmallerContext smaller() {
+			return getRuleContext(SmallerContext.class,0);
+		}
+		public TypeVarContext typeVar() {
+			return getRuleContext(TypeVarContext.class,0);
+		}
+		public TypeContext type() {
+			return getRuleContext(TypeContext.class,0);
+		}
+		public OtherRuleContext otherRule() {
+			return getRuleContext(OtherRuleContext.class,0);
+		}
+		public ResultSetRuleContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_resultSetRule; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).enterResultSetRule(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).exitResultSetRule(this);
+		}
+	}
+
+	public final ResultSetRuleContext resultSetRule() throws RecognitionException {
+		ResultSetRuleContext _localctx = new ResultSetRuleContext(_ctx, getState());
+		enterRule(_localctx, 2, RULE_resultSetRule);
+		try {
+			setState(35);
+			_errHandler.sync(this);
+			switch (_input.LA(1)) {
+			case PARAMLIST_NAME:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(29);
+				parameter();
+				}
+				break;
+			case EQUALS_NAME:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(30);
+				equals();
+				}
+				break;
+			case SMALLER_NAME:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(31);
+				smaller();
+				}
+				break;
+			case TYPEVAR_NAME:
+				enterOuterAlt(_localctx, 4);
+				{
+				setState(32);
+				typeVar();
+				}
+				break;
+			case TYPE_NAME:
+				enterOuterAlt(_localctx, 5);
+				{
+				setState(33);
+				type();
+				}
+				break;
+			case NAME:
+				enterOuterAlt(_localctx, 6);
+				{
+				setState(34);
+				otherRule();
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ParameterListContext extends ParserRuleContext {
+		public List<ValueContext> value() {
+			return getRuleContexts(ValueContext.class);
+		}
+		public ValueContext value(int i) {
+			return getRuleContext(ValueContext.class,i);
+		}
+		public ParameterListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_parameterList; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).enterParameterList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).exitParameterList(this);
+		}
+	}
+
+	public final ParameterListContext parameterList() throws RecognitionException {
+		ParameterListContext _localctx = new ParameterListContext(_ctx, getState());
+		enterRule(_localctx, 4, RULE_parameterList);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(37);
+			match(T__2);
+			setState(38);
+			value();
+			setState(43);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==T__3) {
+				{
+				{
+				setState(39);
+				match(T__3);
+				setState(40);
+				value();
+				}
+				}
+				setState(45);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(46);
+			match(T__4);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ValueContext extends ParserRuleContext {
+		public TerminalNode NAME() { return getToken(UnifyResultParser.NAME, 0); }
+		public ResultSetRuleContext resultSetRule() {
+			return getRuleContext(ResultSetRuleContext.class,0);
+		}
+		public ValueContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_value; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).enterValue(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).exitValue(this);
+		}
+	}
+
+	public final ValueContext value() throws RecognitionException {
+		ValueContext _localctx = new ValueContext(_ctx, getState());
+		enterRule(_localctx, 6, RULE_value);
+		try {
+			setState(50);
+			_errHandler.sync(this);
+			switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(48);
+				match(NAME);
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(49);
+				resultSetRule();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ParameterContext extends ParserRuleContext {
+		public TerminalNode PARAMLIST_NAME() { return getToken(UnifyResultParser.PARAMLIST_NAME, 0); }
+		public ParameterListContext parameterList() {
+			return getRuleContext(ParameterListContext.class,0);
+		}
+		public ParameterContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_parameter; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).enterParameter(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).exitParameter(this);
+		}
+	}
+
+	public final ParameterContext parameter() throws RecognitionException {
+		ParameterContext _localctx = new ParameterContext(_ctx, getState());
+		enterRule(_localctx, 8, RULE_parameter);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(52);
+			match(PARAMLIST_NAME);
+			setState(53);
+			parameterList();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class EqualsContext extends ParserRuleContext {
+		public TerminalNode EQUALS_NAME() { return getToken(UnifyResultParser.EQUALS_NAME, 0); }
+		public ParameterListContext parameterList() {
+			return getRuleContext(ParameterListContext.class,0);
+		}
+		public EqualsContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_equals; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).enterEquals(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).exitEquals(this);
+		}
+	}
+
+	public final EqualsContext equals() throws RecognitionException {
+		EqualsContext _localctx = new EqualsContext(_ctx, getState());
+		enterRule(_localctx, 10, RULE_equals);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(55);
+			match(EQUALS_NAME);
+			setState(56);
+			parameterList();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class SmallerContext extends ParserRuleContext {
+		public TerminalNode SMALLER_NAME() { return getToken(UnifyResultParser.SMALLER_NAME, 0); }
+		public ParameterListContext parameterList() {
+			return getRuleContext(ParameterListContext.class,0);
+		}
+		public SmallerContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_smaller; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).enterSmaller(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).exitSmaller(this);
+		}
+	}
+
+	public final SmallerContext smaller() throws RecognitionException {
+		SmallerContext _localctx = new SmallerContext(_ctx, getState());
+		enterRule(_localctx, 12, RULE_smaller);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(58);
+			match(SMALLER_NAME);
+			setState(59);
+			parameterList();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TypeVarContext extends ParserRuleContext {
+		public TerminalNode TYPEVAR_NAME() { return getToken(UnifyResultParser.TYPEVAR_NAME, 0); }
+		public ParameterListContext parameterList() {
+			return getRuleContext(ParameterListContext.class,0);
+		}
+		public TypeVarContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_typeVar; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).enterTypeVar(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).exitTypeVar(this);
+		}
+	}
+
+	public final TypeVarContext typeVar() throws RecognitionException {
+		TypeVarContext _localctx = new TypeVarContext(_ctx, getState());
+		enterRule(_localctx, 14, RULE_typeVar);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(61);
+			match(TYPEVAR_NAME);
+			setState(62);
+			parameterList();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TypeContext extends ParserRuleContext {
+		public TerminalNode TYPE_NAME() { return getToken(UnifyResultParser.TYPE_NAME, 0); }
+		public ParameterListContext parameterList() {
+			return getRuleContext(ParameterListContext.class,0);
+		}
+		public TypeContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_type; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).enterType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).exitType(this);
+		}
+	}
+
+	public final TypeContext type() throws RecognitionException {
+		TypeContext _localctx = new TypeContext(_ctx, getState());
+		enterRule(_localctx, 16, RULE_type);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(64);
+			match(TYPE_NAME);
+			setState(65);
+			parameterList();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class OtherRuleContext extends ParserRuleContext {
+		public TerminalNode NAME() { return getToken(UnifyResultParser.NAME, 0); }
+		public ParameterListContext parameterList() {
+			return getRuleContext(ParameterListContext.class,0);
+		}
+		public OtherRuleContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_otherRule; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).enterOtherRule(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof UnifyResultListener ) ((UnifyResultListener)listener).exitOtherRule(this);
+		}
+	}
+
+	public final OtherRuleContext otherRule() throws RecognitionException {
+		OtherRuleContext _localctx = new OtherRuleContext(_ctx, getState());
+		enterRule(_localctx, 18, RULE_otherRule);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(67);
+			match(NAME);
+			setState(68);
+			parameterList();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static final String _serializedATN =
+		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\17I\4\2\t\2\4\3\t"+
+		"\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\3"+
+		"\2\3\2\3\2\3\2\7\2\33\n\2\f\2\16\2\36\13\2\3\3\3\3\3\3\3\3\3\3\3\3\5\3"+
+		"&\n\3\3\4\3\4\3\4\3\4\7\4,\n\4\f\4\16\4/\13\4\3\4\3\4\3\5\3\5\5\5\65\n"+
+		"\5\3\6\3\6\3\6\3\7\3\7\3\7\3\b\3\b\3\b\3\t\3\t\3\t\3\n\3\n\3\n\3\13\3"+
+		"\13\3\13\3\13\2\2\f\2\4\6\b\n\f\16\20\22\24\2\2\2F\2\26\3\2\2\2\4%\3\2"+
+		"\2\2\6\'\3\2\2\2\b\64\3\2\2\2\n\66\3\2\2\2\f9\3\2\2\2\16<\3\2\2\2\20?"+
+		"\3\2\2\2\22B\3\2\2\2\24E\3\2\2\2\26\34\7\3\2\2\27\30\5\4\3\2\30\31\7\4"+
+		"\2\2\31\33\3\2\2\2\32\27\3\2\2\2\33\36\3\2\2\2\34\32\3\2\2\2\34\35\3\2"+
+		"\2\2\35\3\3\2\2\2\36\34\3\2\2\2\37&\5\n\6\2 &\5\f\7\2!&\5\16\b\2\"&\5"+
+		"\20\t\2#&\5\22\n\2$&\5\24\13\2%\37\3\2\2\2% \3\2\2\2%!\3\2\2\2%\"\3\2"+
+		"\2\2%#\3\2\2\2%$\3\2\2\2&\5\3\2\2\2\'(\7\5\2\2(-\5\b\5\2)*\7\6\2\2*,\5"+
+		"\b\5\2+)\3\2\2\2,/\3\2\2\2-+\3\2\2\2-.\3\2\2\2.\60\3\2\2\2/-\3\2\2\2\60"+
+		"\61\7\7\2\2\61\7\3\2\2\2\62\65\7\r\2\2\63\65\5\4\3\2\64\62\3\2\2\2\64"+
+		"\63\3\2\2\2\65\t\3\2\2\2\66\67\7\b\2\2\678\5\6\4\28\13\3\2\2\29:\7\t\2"+
+		"\2:;\5\6\4\2;\r\3\2\2\2<=\7\n\2\2=>\5\6\4\2>\17\3\2\2\2?@\7\13\2\2@A\5"+
+		"\6\4\2A\21\3\2\2\2BC\7\f\2\2CD\5\6\4\2D\23\3\2\2\2EF\7\r\2\2FG\5\6\4\2"+
+		"G\25\3\2\2\2\6\34%-\64";
+	public static final ATN _ATN =
+		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
+	static {
+		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
+		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
+			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
+		}
+	}
+}

src/de/dhbwstuttgart/sat/asp/parser/model/ParsedType.java

@@ -0,0 +1,12 @@
+package de.dhbwstuttgart.sat.asp.parser.model;
+
+import java.util.List;
+
+public class ParsedType {
+    public final String name;
+    public final String params;
+    public ParsedType(String name, String params){
+        this.name = name;
+        this.params = params;
+    }
+}

src/de/dhbwstuttgart/sat/asp/writer/ASPFactory.java

@@ -0,0 +1,127 @@
+package de.dhbwstuttgart.sat.asp.writer;
+
+import de.dhbwstuttgart.exceptions.NotImplementedException;
+import de.dhbwstuttgart.parser.SyntaxTreeGenerator.FCGenerator;
+import de.dhbwstuttgart.sat.asp.ASPStringConverter;
+import de.dhbwstuttgart.sat.asp.model.ASPRule;
+import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
+import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
+import de.dhbwstuttgart.syntaxtree.type.*;
+import de.dhbwstuttgart.typeinference.constraints.Constraint;
+import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
+import de.dhbwstuttgart.typeinference.constraints.Pair;
+import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
+
+import java.util.*;
+
+public class ASPFactory implements TypeVisitor<String>{
+
+    public static String generateASP(ConstraintSet<Pair> constraints, Collection<ClassOrInterface> fcClasses) throws ClassNotFoundException{
+        ASPFactory factory = new ASPFactory();
+        factory.convertFC(fcClasses);
+        List<Constraint<Pair>> constraints1 = constraints.cartesianProduct().iterator().next();
+        for(Constraint<Pair> constraint : constraints1){
+            for(Pair p : constraint){
+                factory.convertPair(p);
+            }
+        }
+
+        return factory.writer.getASPFile();
+    }
+
+    ASPWriter writer = new ASPWriter();
+    boolean isFCType = false;
+
+    private void convertFC(Collection<ClassOrInterface> classes) throws ClassNotFoundException {
+        Set<Pair> fc = FCGenerator.toFC(classes);
+        isFCType = true;
+        for(Pair fcp : fc){
+            convertPair(fcp);
+        }
+        isFCType = false;
+    }
+
+    private void convertPair(Pair p){
+        String ls = p.TA1.acceptTV(this);
+        String rs = p.TA2.acceptTV(this);
+        ASPStatement pairStmt = null;
+        if(p.GetOperator().equals(PairOperator.SMALLERDOT)){
+            pairStmt = makeStatement(ASPRule.ASP_PAIR_SMALLER_DOT_NAME.toString(), ls, rs);
+        }else if(p.GetOperator().equals(PairOperator.EQUALSDOT)){
+            pairStmt = makeStatement(ASPRule.ASP_PAIR_EQUALS_NAME.toString(), ls, rs);
+        }else if(p.GetOperator().equals(PairOperator.SMALLER)){
+            pairStmt = makeStatement(ASPRule.ASP_PAIR_SMALLER_NAME.toString(), ls, rs);
+        }else throw new NotImplementedException();
+        writer.add(pairStmt);
+    }
+
+    private ASPStatement makeStatement(String rule, String... params){
+        String stmt = rule + "(";
+        for(String param : params){
+            stmt += param + ",";
+        }
+        stmt = stmt.substring(0,stmt.length()-1);
+        stmt += ")";
+        return new ASPStatement(stmt);
+    }
+
+    private String convertParameterlist(List<String> pointers){
+        String pointer = ASPStringConverter.toConstant(NameGenerator.makeNewName());
+        Iterator<String> it = pointers.iterator();
+        String p = pointer;
+        if(!it.hasNext()){
+            return ASPRule.ASP_PARAMLIST_END_POINTER.toString();
+        }
+        while (it.hasNext()){
+            ASPStatement stmt;
+            String type = it.next();
+            String nextP = ASPStringConverter.toConstant(NameGenerator.makeNewName());
+            if(it.hasNext()){
+                stmt = makeStatement(ASPRule.ASP_PARAMLIST_NAME.toString(), p, type, nextP);
+            }else{
+                stmt = makeStatement(ASPRule.ASP_PARAMLIST_NAME.toString(), p, type,
+                        ASPRule.ASP_PARAMLIST_END_POINTER.toString());
+            }
+            p = nextP;
+            writer.add(stmt);
+        }
+        return pointer;
+    }
+
+    @Override
+    public String visit(RefType refType) {
+        String pointer = ASPStringConverter.toConstant(NameGenerator.makeNewName());
+        List<String> params = new ArrayList<>();
+        for(RefTypeOrTPHOrWildcardOrGeneric param : refType.getParaList()){
+            params.add(param.acceptTV(this));
+        }
+        String typeName = ASPStringConverter.toConstant(refType.getName());
+        String ruleName = isFCType?ASPRule.ASP_FCTYPE.toString():ASPRule.ASP_TYPE.toString();
+        ASPStatement stmt = makeStatement(ruleName, pointer, typeName, convertParameterlist(params));
+        writer.add(stmt);
+        return pointer;
+    }
+
+    @Override
+    public String visit(SuperWildcardType superWildcardType) {
+        throw new NotImplementedException();
+    }
+
+    @Override
+    public String visit(TypePlaceholder typePlaceholder) {
+        String name = ASPStringConverter.toConstant(typePlaceholder.getName());
+        ASPStatement stmt = makeStatement(ASPRule.ASP_TYPE_VAR.toString(), name);
+        writer.add(stmt);
+        return name;
+    }
+
+    @Override
+    public String visit(ExtendsWildcardType extendsWildcardType) {
+        throw new NotImplementedException();
+    }
+
+    @Override
+    public String visit(GenericRefType genericRefType) {
+        throw new NotImplementedException();
+    }
+}

src/de/dhbwstuttgart/sat/asp/writer/ASPGencayFactory.java

@@ -0,0 +1,264 @@
+package de.dhbwstuttgart.sat.asp.writer;
+
+import de.dhbwstuttgart.exceptions.NotImplementedException;
+import de.dhbwstuttgart.parser.SyntaxTreeGenerator.FCGenerator;
+import de.dhbwstuttgart.sat.asp.ASPStringConverter;
+import de.dhbwstuttgart.sat.asp.model.ASPGencayRule;
+import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
+import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
+import de.dhbwstuttgart.syntaxtree.type.*;
+import de.dhbwstuttgart.typeinference.constraints.Constraint;
+import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
+import de.dhbwstuttgart.typeinference.constraints.Pair;
+import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
+
+import java.util.*;
+
+
+public class ASPGencayFactory implements TypeVisitor<String> {
+    /* TODO:
+     * Alle TPHs müssen als var(tph) definiert sein
+     * Wenn es eine Variable ist, dann direkt in die type-Regel schreiben: type(p, type, tph)
+     * Für die FCTypen eindeutige Namen für die pph-Regeln
+     *  (ergibt sich von selbst, weil man einfach den Namen der TPH in der FC verwenden kann)
+     * paramOrder wird benötigt!
+     *  Nur bei parameterlisten > 1
+     *  paramOrder(paralistPointer, parameter, num)
+     *  (ähnlich meiner paramNum)
+     * Trennung von FC und Eq:
+     *  sub -> type -> param
+     *  ...Eq -> typeEq -> paramEq
+     * type..(_,_,_p): p kann sein:
+     *  1. Variable
+     *  2. ParameterPointer
+     *  3. null
+     */
+    ASPWriter writer = new ASPWriter();
+    boolean isFCType = false;
+
+    private static List<ASPStatement> generateVar(ConstraintSet<Pair> constraints){
+        List<ASPStatement> ret = new ArrayList<>();
+        for(TypePlaceholder tph : getInvolvedTPHS(constraints)){
+            ret.add(makeStatement(ASPGencayRule.ASP_TYPE_VAR.toString(),
+                    ASPStringConverter.toConstant(tph.getName())));
+        }
+        return ret;
+    }
+
+    protected static Collection<TypePlaceholder> getInvolvedTPHS(ConstraintSet<Pair> toTest) {
+        List<TypePlaceholder> ret = new ArrayList<>();
+        toTest.map((Pair p)-> {
+            ret.addAll(p.TA1.acceptTV(new TPHExtractor()));
+            ret.addAll(p.TA2.acceptTV(new TPHExtractor()));
+            return p;
+        });
+        return ret;
+    }
+
+    public static String generateASP(ConstraintSet<Pair> constraints, Collection<ClassOrInterface> fcClasses) throws ClassNotFoundException{
+        ASPGencayFactory factory = new ASPGencayFactory();
+        factory.convertFC(fcClasses);
+        List<Constraint<Pair>> constraints1 = constraints.cartesianProduct().iterator().next();
+        for(Constraint<Pair> constraint : constraints1){
+            for(Pair p : constraint){
+                factory.convertPair(p);
+            }
+        }
+        factory.writer.addAll(generateVar(constraints));
+
+        return factory.writer.getASPFile();
+    }
+
+    private void convertFC(Collection<ClassOrInterface> classes) throws ClassNotFoundException {
+        Set<Pair> fc = FCGenerator.toFC(classes);
+        isFCType = true;
+        for(Pair fcp : fc){
+            generateTheta((RefType) fcp.TA1);
+            generateTheta((RefType) fcp.TA2);
+            convertPair(fcp);
+        }
+        isFCType = false;
+    }
+
+    private void generateTheta(RefType t){
+        String rule = "theta"+t.getParaList().size() ;
+        String name = ASPStringConverter.toConstant(t.getName());
+        writer.add(makeStatement(rule, name));
+    }
+
+    private void convertPair(Pair p){
+        String ls = p.TA1.acceptTV(this);
+        String rs = p.TA2.acceptTV(this);
+        ASPStatement pairStmt = null;
+        if(p.GetOperator().equals(PairOperator.SMALLERDOT)){
+            pairStmt = makeStatement(ASPGencayRule.ASP_PAIR_SMALLER_DOT_NAME.toString(), ls, rs);
+        }else if(p.GetOperator().equals(PairOperator.EQUALSDOT)){
+            pairStmt = makeStatement(ASPGencayRule.ASP_PAIR_EQUALS_NAME.toString(), ls, rs);
+        }else if(p.GetOperator().equals(PairOperator.SMALLER)){
+            pairStmt = makeStatement(ASPGencayRule.ASP_PAIR_SMALLER_NAME.toString(), ls, rs);
+        }else throw new NotImplementedException();
+        writer.add(pairStmt);
+    }
+
+    private static ASPStatement makeStatement(String rule, String... params){
+        String stmt = rule + "(";
+        for(String param : params){
+            stmt += param + ",";
+        }
+        stmt = stmt.substring(0,stmt.length()-1);
+        stmt += ")";
+        return new ASPStatement(stmt);
+    }
+
+    private String convertParameterlist(List<String> pointers){
+        //if(pointers.size()==1)return pointers.get(0);
+        String pointer = ASPStringConverter.toConstant(NameGenerator.makeNewName());
+        Iterator<String> it = pointers.iterator();
+        String p = pointer;
+        String paramname = ASPGencayRule.ASP_PARAMLIST_NAME.toString();
+        if(this.isFCType)paramname = ASPGencayRule.ASP_FC_PARAMLIST_NAME.toString();
+        if(!it.hasNext()){
+            return ASPGencayRule.ASP_PARAMLIST_END_POINTER.toString();
+        }
+        while (it.hasNext()){
+            ASPStatement stmt;
+            String type = it.next();
+            String nextP = ASPStringConverter.toConstant(NameGenerator.makeNewName());
+            if(it.hasNext()){
+                stmt = makeStatement(paramname, p, type, nextP);
+            }else{
+                stmt = makeStatement(paramname, p, type,
+                        ASPGencayRule.ASP_PARAMLIST_END_POINTER.toString());
+            }
+            p = nextP;
+            writer.add(stmt);
+        }
+        return pointer;
+    }
+
+    //Wird zum erstellen der pph(..) Regeln gebraucht
+    private String currentFCTypePointer = "";
+    @Override
+    public String visit(RefType refType) {
+        String pointer = ASPStringConverter.toConstant(NameGenerator.makeNewName());
+        currentFCTypePointer = pointer;
+        String paramPointer = ASPGencayRule.ASP_PARAMLIST_END_POINTER.toString();
+        if(refType.getParaList().size() == 1 ){
+            if(refType.getParaList().get(0) instanceof TypePlaceholder){
+                TypePlaceholder typePlaceholder = (TypePlaceholder) refType.getParaList().get(0);
+                paramPointer = typePlaceholder.acceptTV(this);
+            }
+        }else{
+            List<String> params = null;
+            params = generateParameter(refType);
+            params.remove(0);
+            paramPointer = convertParameterlist(params);
+            if(refType.getParaList().size()>1){
+                //paramOrder generieren:
+                for(String param : params) {
+                    ASPStatement pOstmt = makeStatement(ASPGencayRule.ASP_PARAMLIST_ORDER.toString(),
+                            paramPointer, param);
+                    writer.add(pOstmt);
+                }
+            }
+        }
+        String typeName = ASPStringConverter.toConstant(refType.getName());
+        String ruleName = isFCType? ASPGencayRule.ASP_FCTYPE.toString(): ASPGencayRule.ASP_TYPE.toString();
+        ASPStatement stmt = makeStatement(ruleName, pointer, typeName, paramPointer);
+        writer.add(stmt);
+        return pointer;
+        /*
+        String pointer = ASPStringConverter.toConstant(NameGenerator.makeNewName());
+        List<String> params = null;
+        params = generateParameter(refType);
+        params.remove(0); //Das erste ist der eigentliche Typ kein parameter
+        String typeName = ASPStringConverter.toConstant(refType.getName());
+        String ruleName = isFCType? ASPGencayRule.ASP_FCTYPE.toString(): ASPGencayRule.ASP_TYPE.toString();
+        ASPStatement stmt = makeStatement(ruleName, pointer, typeName, convertParameterlist(params));
+        writer.add(stmt);
+        return pointer;
+        */
+    }
+
+    /**
+     * Erstellt die Parameterliste, wobei type auch schon als Parameter betrachtet wird.
+     * Die RefTypes werden nicht zu extra type-Regeln umgewandelt. Es wird nur ihr Name als Konstante benutzt
+     * Das funktioniert, weil nacher das ParamOrder zuteilt, welche Typen zusammenhängen.
+     * Diese funktion nur verwenden, wenn auch ein paramOrder generiert wird
+     */
+    private List<String> generateParameter(RefType type){
+        List<String> ret = new ArrayList<>();
+        ret.add(ASPStringConverter.toConstant(type.getName()));
+        for(RefTypeOrTPHOrWildcardOrGeneric param : type.getParaList()){
+            if(param instanceof RefType){
+                ret.addAll(generateParameter((RefType) param));
+            }else if(param instanceof TypePlaceholder){
+                ret.add(param.acceptTV(this));
+            }else throw new NotImplementedException();
+        }
+        return ret;
+    }
+
+    @Override
+    public String visit(SuperWildcardType superWildcardType) {
+        throw new NotImplementedException();
+    }
+
+    @Override
+    public String visit(TypePlaceholder typePlaceholder) {
+        String name = ASPStringConverter.toConstant(typePlaceholder.getName());
+
+        ASPStatement stmt = null;
+        if(isFCType){
+            stmt = makeStatement(ASPGencayRule.ASP_GENERIC_VAR.toString(),
+                    currentFCTypePointer, name);
+        } else {
+            stmt = makeStatement(ASPGencayRule.ASP_TYPE_VAR.toString(), name);
+        }
+
+        writer.add(stmt);
+        return name;
+    }
+
+    @Override
+    public String visit(ExtendsWildcardType extendsWildcardType) {
+        throw new NotImplementedException();
+    }
+
+    @Override
+    public String visit(GenericRefType genericRefType) {
+        throw new NotImplementedException();
+    }
+
+    private static class TPHExtractor implements TypeVisitor<List<TypePlaceholder>>{
+        @Override
+        public List<TypePlaceholder> visit(RefType refType) {
+            ArrayList<TypePlaceholder> ret = new ArrayList<>();
+            for(RefTypeOrTPHOrWildcardOrGeneric param : refType.getParaList()){
+                ret.addAll(param.acceptTV(this));
+            }
+            return ret;
+        }
+
+        @Override
+        public List<TypePlaceholder> visit(SuperWildcardType superWildcardType) {
+            return superWildcardType.getInnerType().acceptTV(this);
+        }
+
+        @Override
+        public List<TypePlaceholder> visit(TypePlaceholder typePlaceholder) {
+            return Arrays.asList(typePlaceholder);
+        }
+
+        @Override
+        public List<TypePlaceholder> visit(ExtendsWildcardType extendsWildcardType) {
+            return extendsWildcardType.getInnerType().acceptTV(this);
+        }
+
+        @Override
+        public List<TypePlaceholder> visit(GenericRefType genericRefType) {
+            return new ArrayList<>();
+        }
+    }
+
+}

src/de/dhbwstuttgart/sat/asp/writer/ASPStatement.java

@@ -0,0 +1,27 @@
+package de.dhbwstuttgart.sat.asp.writer;
+
+public class ASPStatement {
+    private final String stmt;
+    public ASPStatement(String stmt) {
+        this.stmt = stmt;
+    }
+
+    public String toString(){
+        return stmt;
+    }
+
+    @Override
+    public int hashCode() {
+        return stmt.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if(obj instanceof ASPStatement)return stmt.equals(((ASPStatement) obj).stmt);
+        return false;
+    }
+
+    public String getASP() {
+        return stmt;
+    }
+}

src/de/dhbwstuttgart/sat/asp/writer/ASPWriter.java

@@ -0,0 +1,26 @@
+package de.dhbwstuttgart.sat.asp.writer;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+
+public class ASPWriter {
+
+    private HashSet<ASPStatement> content = new HashSet<>();
+
+    public void add(ASPStatement stmt){
+        content.add(stmt);
+    }
+
+    public String getASPFile(){
+        String ret = "";
+        for(ASPStatement statement : content){
+            ret += statement.getASP() + ".\n";
+        }
+        return ret;
+    }
+
+    public void addAll(Collection<ASPStatement> aspStatements) {
+        content.addAll(aspStatements);
+    }
+}

src/de/dhbwstuttgart/syntaxtree/AbstractASTWalker.java

@@ -66,10 +66,10 @@ public abstract class AbstractASTWalker implements ASTVisitor{
 
     @Override
     public void visit(ParameterList formalParameters) {
-        Iterator<FormalParameter> it = formalParameters.getFormalparalist().iterator();
+        Iterator<FormalParameter> genericIterator = formalParameters.getFormalparalist().iterator();
-        if(it.hasNext()){
+        if(genericIterator.hasNext()){
-            while(it.hasNext()){
+            while(genericIterator.hasNext()){
-                it.next().accept(this);
+                genericIterator.next().accept(this);
             }
         }
     }
@@ -80,9 +80,6 @@ public abstract class AbstractASTWalker implements ASTVisitor{
         for(Field f : classOrInterface.getFieldDecl()){
             f.accept(this);
         }
-        for(Constructor c : classOrInterface.getConstructors()){
-            c.accept(this);
-        }
         for(Method m : classOrInterface.getMethods()){
             m.accept(this);
         }

src/de/dhbwstuttgart/syntaxtree/ClassOrInterface.java

@@ -3,7 +3,6 @@ package de.dhbwstuttgart.syntaxtree;
 import de.dhbwstuttgart.core.IItemWithOffset;
 import de.dhbwstuttgart.exceptions.DebugException;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
-import de.dhbwstuttgart.syntaxtree.statement.Statement;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
@@ -13,21 +12,17 @@ import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
 import org.antlr.v4.runtime.Token;
 
-import java.lang.reflect.Modifier;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
-import java.util.Optional;
 
 /**
  * Stellt jede Art von Klasse dar. Auch abstrakte Klassen und Interfaces
  */
 public class ClassOrInterface extends SyntaxTreeNode implements TypeScope{
-  private Boolean methodAdded = false; //wird benoetigt bei in JavaTXCompiler.getConstraints()
   protected int modifiers;
   protected JavaClassName name;
   private List<Field> fields = new ArrayList<>();
-  private Optional<Constructor> fieldInitializations; //PL 2018-11-24: Noetig, um Bytecode fuer initializators nur einmal zu erzeugen
   private List<Method> methods = new ArrayList<>();
   private GenericDeclarationList genericClassParameters;
   private RefType superClass;
@@ -35,15 +30,12 @@ public class ClassOrInterface extends SyntaxTreeNode implements TypeScope{
   private List<RefType> implementedInterfaces;
   private List<Constructor> constructors;
 
-  
+  public ClassOrInterface(int modifiers, JavaClassName name, List<Field> fielddecl, List<Method> methods, List<Constructor> constructors, GenericDeclarationList genericClassParameters,
-  public ClassOrInterface(int modifiers, JavaClassName name, List<Field> fielddecl, Optional<Constructor> fieldInitializations, List<Method> methods, List<Constructor> constructors, GenericDeclarationList genericClassParameters,
                           RefType superClass, Boolean isInterface, List<RefType> implementedInterfaces, Token offset){
     super(offset);
-    if(isInterface && !Modifier.isInterface(modifiers))modifiers += Modifier.INTERFACE;
       this.modifiers = modifiers;
       this.name = name;
       this.fields = fielddecl;
-      this.fieldInitializations= fieldInitializations;
     this.genericClassParameters = genericClassParameters;
       this.superClass = superClass;
     this.isInterface = isInterface;
@@ -52,33 +44,6 @@ public class ClassOrInterface extends SyntaxTreeNode implements TypeScope{
     this.constructors = constructors;
   }
   
-  /* erzeugt fuer Fields, Konstruktoren und Methoden neue ArrayList-Objekte 
-   * alle anderen Datenobjekte werden nur kopiert.
-   */
-  public ClassOrInterface(ClassOrInterface cl){
-	  super(cl.getOffset());
-	  this.modifiers = cl.modifiers;
-	  this.name = cl.name;
-	  this.fields = new ArrayList<>(cl.fields);
-	  this.fieldInitializations= cl.fieldInitializations;
-	  this.genericClassParameters = cl.genericClassParameters;
-	  this.superClass = cl.superClass;
-	  this.isInterface = cl.isInterface;
-	  this.implementedInterfaces = cl.implementedInterfaces;
-	  this.methods = new ArrayList<>(cl.methods);
-	  this.constructors = new ArrayList<>(cl.constructors);
-  }
-  
-  //Gets if it is added
-  public Boolean areMethodsAdded() {
-	  return methodAdded;
-  }
-  
-  //Sets that it is added
-  public void setMethodsAdded() {
-	methodAdded = true;	
-  }
-  
   // Gets class name
   public JavaClassName getClassName(){
     return this.name;
@@ -92,11 +57,6 @@ public class ClassOrInterface extends SyntaxTreeNode implements TypeScope{
   public List<Field> getFieldDecl(){
     return this.fields;
   }
-  
-  public Optional<Constructor> getfieldInitializations(){
-	    return this.fieldInitializations;
-	  }
-  
   public List<Method> getMethods(){
     return this.methods;
   }

src/de/dhbwstuttgart/syntaxtree/Constructor.java

@@ -15,8 +15,8 @@ public class Constructor extends Method {
 
 	//TODO: Constructor braucht ein super-Statement
 	public Constructor(int modifier, String name, RefTypeOrTPHOrWildcardOrGeneric returnType, ParameterList parameterList, Block codeInsideConstructor,
-					   GenericDeclarationList gtvDeclarations, Token offset /*, List<Statement> fieldInitializations geloescht PL 2018-11-24 */) {
+					   GenericDeclarationList gtvDeclarations, Token offset, List<Statement> fieldInitializations) {
-		super(modifier, name, returnType, parameterList, /*codeInsideConstructor,*/ prepareBlock(codeInsideConstructor ) /*,fieldInitializations )geloescht PL 2018-11-24 )*/, gtvDeclarations, offset);
+		super(modifier, name, returnType, parameterList, prepareBlock(codeInsideConstructor,fieldInitializations), gtvDeclarations, offset);
 
 	}
 
@@ -25,10 +25,9 @@ public class Constructor extends Method {
 	 *                                welche die Felder der zugehörigen Klasse dieses
 	 *                                Konstruktor initialisieren
 	 */
-	protected static Block prepareBlock(Block constructorBlock /*, List<Statement> fieldInitializations new ArrayList<>() geloescht PL 2018-11-24 */){
+	protected static Block prepareBlock(Block constructorBlock, List<Statement> fieldInitializations){
 		List<Statement> statements = constructorBlock.getStatements();
-		statements.add(0, new SuperCall(null, null, constructorBlock.getOffset()));
+		statements.add(0, new SuperCall(constructorBlock.getOffset()));
-		/* statements.addAll(fieldInitializations); geloescht PL 2018-11-24 */
 		return new Block(statements, constructorBlock.getOffset());
 	}
 

src/de/dhbwstuttgart/syntaxtree/FieldDeclaration.java

@@ -6,7 +6,7 @@ import org.antlr.v4.runtime.Token;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 
 /**
- * Eine Feldinitialisation steht für eine Felddeklaration mit gleichzeitiger Wertzuweisung
+ * Eine Feldinitialisation steht für eine Felddeklaration mit gleichzeitiger Wertzuweisung
  * Beispiel: 'public Feld FeldVar = FeldWert;'
  * @author janulrich
  *
@@ -17,7 +17,7 @@ public class FieldDeclaration extends Field{
 	
     /**
      * Dieser Konstruktor der FieldDeclaration erstellt den Syntaxknoten vollständig.
-     * Kein nachträgliches hinzfügen von Informationen oder aufrufen von parserPostProcessing ist notwendig.
+     * Kein nachträgliches hinzfügen von Informationen oder aufrufen von parserPostProcessing ist notwendig.
      */
     public FieldDeclaration(String name, RefTypeOrTPHOrWildcardOrGeneric typ, int modifier, Expression value, Token offset){
     	super(name, typ, modifier, offset);//Dieser Deklarator wird nicht vom Parser aufgerufen. Dadurch gibt es auch keinen Offset

src/de/dhbwstuttgart/syntaxtree/GenericDeclarationList.java

@@ -2,10 +2,6 @@ package de.dhbwstuttgart.syntaxtree;
 
 import org.antlr.v4.runtime.Token;
 
-import com.google.common.collect.Lists;
-
-import de.dhbwstuttgart.parser.NullToken;
-
 import java.util.*;
 
 
@@ -20,20 +16,10 @@ public class GenericDeclarationList extends SyntaxTreeNode implements Iterable<G
 	private Token offsetOfLastElement;
 	private List<GenericTypeVar> gtvs = new ArrayList<>();
 	
-	@SuppressWarnings("unchecked")
+	public GenericDeclarationList(List<GenericTypeVar> values, Token endOffset) {
-	public GenericDeclarationList(Iterable<? extends GenericTypeVar> values, Token endOffset) {
-		super(endOffset);
-		gtvs = isListOfGenericTypeVar(values) ? (List<GenericTypeVar>)values : Lists.newArrayList(values);
-		this.offsetOfLastElement = endOffset;
-	}
-
-	public GenericDeclarationList(ArrayList<GenericTypeVar> values, Token endOffset) {
 		super(endOffset);
 		gtvs = values;
-		this.offsetOfLastElement = endOffset;	}
+		this.offsetOfLastElement = endOffset;
-
-	private boolean isListOfGenericTypeVar(Iterable<? extends GenericTypeVar> values) {
-		return values instanceof List && ((List<?>)values).size() > 0 && ((List<?>)values).get(0) instanceof GenericTypeVar;
 	}
 
 	@Override

src/de/dhbwstuttgart/syntaxtree/Method.java

@@ -31,7 +31,6 @@ public class Method extends SyntaxTreeNode implements IItemWithOffset, TypeScope
 	private ExceptionList exceptionlist;
 	private GenericDeclarationList generics;
 	private final RefTypeOrTPHOrWildcardOrGeneric returnType;
-	public final Boolean isInherited;  
 
 	public Method(int modifier, String name, RefTypeOrTPHOrWildcardOrGeneric returnType, ParameterList parameterList, Block block,
 				  GenericDeclarationList gtvDeclarations, Token offset) {
@@ -42,19 +41,6 @@ public class Method extends SyntaxTreeNode implements IItemWithOffset, TypeScope
 		this.parameterlist = parameterList;
 		this.block = block;
 		this.generics = gtvDeclarations;
-		this.isInherited = false;
-	}
-	
-	public Method(int modifier, String name, RefTypeOrTPHOrWildcardOrGeneric returnType, ParameterList parameterList, Block block,
-			  GenericDeclarationList gtvDeclarations, Token offset, Boolean isInherited) {
-		super(offset);
-		this.name = name;
-		this.modifier = modifier;
-		this.returnType = returnType;
-		this.parameterlist = parameterList;
-		this.block = block;
-		this.generics = gtvDeclarations;
-		this.isInherited = isInherited;
 	}
 
 	public ParameterList getParameterList() {
@@ -77,7 +63,7 @@ public class Method extends SyntaxTreeNode implements IItemWithOffset, TypeScope
 
 	@Override
 	public Token getOffset() {
-		return super.getOffset();
+		return null;
 	}
 
 	public String getName() {

src/de/dhbwstuttgart/syntaxtree/SourceFile.java

@@ -26,13 +26,6 @@ public class SourceFile extends SyntaxTreeNode{
     this.imports = imports;
   }
   
-  public SourceFile(SourceFile sf) {
-	  super(new NullToken());
-	  this.KlassenVektor = new ArrayList<>(sf.KlassenVektor);
-	  this.imports = new HashSet<>(sf.imports);
-  }
-  
-  
   public String getPkgName(){
     return this.pkgName;
   }