Merge branch 'bytecode' into unifyDev

.classpath

@@ -1,11 +1,14 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <classpath>
 	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="BCEL"/>
+	<classpathentry excluding=".classpath|.cvsignore|.externalToolBuilders/|.project|.settings/|Papers/|bin/|doc/|examples/|lib/|notizen/|src/|test/|tools/|BCEL/" including="log4j.xml" kind="src" path=""/>
 	<classpathentry kind="src" path="test"/>
 	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
-	<classpathentry kind="lib" path="lib/bcel-6.1-SNAPSHOT.jar" sourcepath="lib/bcel-6.1-SNAPSHOT-sources.jar"/>
+	<classpathentry kind="lib" path="lib/junit-4.0.jar" sourcepath="/home/janulrich/.m2/repository/junit/junit/4.0/junit-4.0-sources.jar"/>
+	<classpathentry kind="lib" path="lib/cloning.jar"/>
 	<classpathentry kind="lib" path="lib/guava-10.0.1.jar"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
-	<classpathentry kind="lib" path="lib/antlr-complete.jar"/>
+	<classpathentry kind="lib" path="lib/commons-bcel6-6.0-SNAPSHOT.jar" sourcepath="/home/janulrich/Development/intellijworkspace/bcel/src/main/java"/>
+	<classpathentry kind="lib" path="lib/bcel-6.0-SNAPSHOT.jar"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>

.cvsignore

@@ -0,0 +1,12 @@
+bin
+*.class
+output*
+JavaLexer.java
+JavaParser.java
+*.~*~
+*.aux
+*.dvi
+*.log
+y.output
+Bytecode
+JavaParserBuilder.launch

.externalToolBuilders/JavaParserBuilder.launch

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<launchConfiguration type="org.eclipse.ant.AntBuilderLaunchConfigurationType">
+<booleanAttribute key="org.eclipse.ant.ui.ATTR_TARGETS_UPDATED" value="true"/>
+<booleanAttribute key="org.eclipse.ant.ui.DEFAULT_VM_INSTALL" value="false"/>
+<stringAttribute key="org.eclipse.debug.core.ATTR_REFRESH_SCOPE" value="${workspace}"/>
+<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
+<listEntry value="/JavaCompilerCore"/>
+</listAttribute>
+<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
+<listEntry value="4"/>
+</listAttribute>
+<booleanAttribute key="org.eclipse.debug.core.appendEnvironmentVariables" value="true"/>
+<booleanAttribute key="org.eclipse.debug.ui.ATTR_LAUNCH_IN_BACKGROUND" value="false"/>
+<stringAttribute key="org.eclipse.jdt.launching.CLASSPATH_PROVIDER" value="org.eclipse.ant.ui.AntClasspathProvider"/>
+<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="JavaCompilerCore"/>
+<booleanAttribute key="org.eclipse.ui.externaltools.ATTR_BUILDER_ENABLED" value="false"/>
+<stringAttribute key="org.eclipse.ui.externaltools.ATTR_LOCATION" value="${workspace_loc:/JavaCompilerCore/tools/AntParserBuilderWindows.xml}"/>
+<stringAttribute key="org.eclipse.ui.externaltools.ATTR_RUN_BUILD_KINDS" value="incremental,clean"/>
+<booleanAttribute key="org.eclipse.ui.externaltools.ATTR_TRIGGERS_CONFIGURED" value="true"/>
+<stringAttribute key="org.eclipse.ui.externaltools.ATTR_WORKING_DIRECTORY" value="${workspace_loc:/JavaCompilerCore/tools}"/>
+</launchConfiguration>

.project

@@ -5,6 +5,20 @@
 	<projects>
 	</projects>
 	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.ui.externaltools.ExternalToolBuilder</name>
+			<triggers>clean,full,incremental,</triggers>
+			<arguments>
+				<dictionary>
+					<key>LaunchConfigHandle</key>
+					<value>&lt;project&gt;/.externalToolBuilders/JavaParserBuilder.launch</value>
+				</dictionary>
+				<dictionary>
+					<key>incclean</key>
+					<value>true</value>
+				</dictionary>
+			</arguments>
+		</buildCommand>
 		<buildCommand>
 			<name>org.eclipse.jdt.core.javabuilder</name>
 			<arguments>

.settings/com.google.gwt.eclipse.core.prefs

@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+filesCopiedToWebInfLib=

.settings/org.eclipse.core.resources.prefs

@@ -0,0 +1,5 @@
+eclipse.preferences.version=1
+encoding//src/de/dhbwstuttgart/core/MyCompiler.java=UTF-8
+encoding//src/de/dhbwstuttgart/syntaxtree/statement/LambdaExpression.java=UTF-8
+encoding//src/de/dhbwstuttgart/typeinference/SingleConstraint.java=UTF-8
+encoding//src/de/dhbwstuttgart/typeinference/UndConstraint.java=UTF-8

.settings/org.eclipse.jdt.core.prefs

@@ -1,12 +1,13 @@
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.methodParameters=do not generate
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
-org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.8
-org.eclipse.jdt.core.compiler.debug.lineNumber=generate
-org.eclipse.jdt.core.compiler.debug.localVariable=generate
-org.eclipse.jdt.core.compiler.debug.sourceFile=generate
-org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
-org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.source=1.8
+eclipse.preferences.version=1
+instance/org.eclipse.core.net/org.eclipse.core.net.hasMigrated=true
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.methodParameters=do not generate
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8

.settings/org.eclipse.jdt.ui.prefs

@@ -0,0 +1,4 @@
+#Sun Jul 27 10:21:29 CEST 2008
+eclipse.preferences.version=1
+instance/org.eclipse.core.net/org.eclipse.core.net.hasMigrated=true
+internal.default.compliance=default

BCEL/bcelifier/BooleanValue.java

@@ -0,0 +1,6 @@
+package bcelifier;
+
+public class BooleanValue {
+	Boolean c = true;
+	Boolean b = c.booleanValue();
+}

BCEL/bcelifier/BooleanValueCreator.java

@@ -0,0 +1,63 @@
+package bcelifier;
+
+import org.apache.commons.bcel6.generic.*;
+import org.apache.commons.bcel6.classfile.*;
+import org.apache.commons.bcel6.*;
+import java.io.*;
+
+public class BooleanValueCreator implements Constants {
+  private InstructionFactory _factory;
+  private ConstantPoolGen    _cp;
+  private ClassGen           _cg;
+
+  public BooleanValueCreator() {
+    _cg = new ClassGen("bcelifier.BooleanValue", "java.lang.Object", "BooleanValue.java", ACC_PUBLIC | ACC_SUPER, new String[] {  });
+
+    _cp = _cg.getConstantPool();
+    _factory = new InstructionFactory(_cg, _cp);
+  }
+
+  public void create(OutputStream out) throws IOException {
+    createFields();
+    createMethod_0();
+    _cg.getJavaClass().dump(out);
+  }
+
+  private void createFields() {
+    FieldGen field;
+
+    field = new FieldGen(0, new ObjectType("java.lang.Boolean"), "c", _cp);
+    _cg.addField(field.getField());
+
+    field = new FieldGen(0, new ObjectType("java.lang.Boolean"), "b", _cp);
+    _cg.addField(field.getField());
+  }
+
+  private void createMethod_0() {
+    InstructionList il = new InstructionList();
+    MethodGen method = new MethodGen(ACC_PUBLIC, Type.VOID, Type.NO_ARGS, new String[] {  }, "<init>", "bcelifier.BooleanValue", il, _cp);
+
+    InstructionHandle ih_0 = il.append(_factory.createLoad(Type.OBJECT, 0));
+    il.append(_factory.createInvoke("java.lang.Object", "<init>", Type.VOID, Type.NO_ARGS, Constants.INVOKESPECIAL));
+    InstructionHandle ih_4 = il.append(_factory.createLoad(Type.OBJECT, 0));
+    il.append(new PUSH(_cp, 1));
+    il.append(_factory.createInvoke("java.lang.Boolean", "valueOf", new ObjectType("java.lang.Boolean"), new Type[] { Type.BOOLEAN }, Constants.INVOKESTATIC));
+    il.append(_factory.createFieldAccess("bcelifier.BooleanValue", "c", new ObjectType("java.lang.Boolean"), Constants.PUTFIELD));
+    InstructionHandle ih_12 = il.append(_factory.createLoad(Type.OBJECT, 0));
+    il.append(_factory.createLoad(Type.OBJECT, 0));
+    il.append(_factory.createFieldAccess("bcelifier.BooleanValue", "c", new ObjectType("java.lang.Boolean"), Constants.GETFIELD));
+    il.append(_factory.createInvoke("java.lang.Boolean", "booleanValue", Type.BOOLEAN, Type.NO_ARGS, Constants.INVOKEVIRTUAL));
+    il.append(_factory.createInvoke("java.lang.Boolean", "valueOf", new ObjectType("java.lang.Boolean"), new Type[] { Type.BOOLEAN }, Constants.INVOKESTATIC));
+    il.append(_factory.createFieldAccess("bcelifier.BooleanValue", "b", new ObjectType("java.lang.Boolean"), Constants.PUTFIELD));
+    InstructionHandle ih_26 = il.append(_factory.createReturn(Type.VOID));
+    method.setMaxStack();
+    method.setMaxLocals();
+    _cg.addMethod(method.getMethod());
+    il.dispose();
+  }
+
+  public static void main(String[] args) throws Exception {
+    bcelifier.BooleanValueCreator creator = new bcelifier.BooleanValueCreator();
+    creator.create(new FileOutputStream("bcelifier.BooleanValue.class"));
+  }
+}

BCEL/bcelifier/FieldDeclaration.java

@@ -0,0 +1,11 @@
+package bcelifier;
+
+public class FieldDeclaration {
+
+	Integer field = methode();
+	
+	Integer methode()
+	{
+		return field;
+	}
+}

BCEL/bcelifier/FieldDeclarationCreator.java

@@ -0,0 +1,68 @@
+package bcelifier;
+
+import org.apache.commons.bcel6.generic.*;
+import org.apache.commons.bcel6.classfile.*;
+import org.apache.commons.bcel6.*;
+import java.io.*;
+
+public class FieldDeclarationCreator implements Constants {
+  private InstructionFactory _factory;
+  private ConstantPoolGen    _cp;
+  private ClassGen           _cg;
+
+  public FieldDeclarationCreator() {
+    _cg = new ClassGen("bcelifier.FieldDeclaration", "java.lang.Object", "FieldDeclaration.java", ACC_PUBLIC | ACC_SUPER, new String[] {  });
+
+    _cp = _cg.getConstantPool();
+    _factory = new InstructionFactory(_cg, _cp);
+  }
+
+  public void create(OutputStream out) throws IOException {
+    createFields();
+    createMethod_0();
+    createMethod_1();
+    _cg.getJavaClass().dump(out);
+  }
+
+  private void createFields() {
+    FieldGen field;
+
+    field = new FieldGen(0, new ObjectType("java.lang.Integer"), "field", _cp);
+    _cg.addField(field.getField());
+  }
+
+  private void createMethod_0() {
+    InstructionList il = new InstructionList();
+    MethodGen method = new MethodGen(ACC_PUBLIC, Type.VOID, Type.NO_ARGS, new String[] {  }, "<init>", "bcelifier.FieldDeclaration", il, _cp);
+
+    InstructionHandle ih_0 = il.append(_factory.createLoad(Type.OBJECT, 0));
+    il.append(_factory.createInvoke("java.lang.Object", "<init>", Type.VOID, Type.NO_ARGS, Constants.INVOKESPECIAL));
+    InstructionHandle ih_4 = il.append(_factory.createLoad(Type.OBJECT, 0));
+    il.append(_factory.createLoad(Type.OBJECT, 0));
+    il.append(_factory.createInvoke("bcelifier.FieldDeclaration", "methode", new ObjectType("java.lang.Integer"), Type.NO_ARGS, Constants.INVOKEVIRTUAL));
+    il.append(_factory.createFieldAccess("bcelifier.FieldDeclaration", "field", new ObjectType("java.lang.Integer"), Constants.PUTFIELD));
+    InstructionHandle ih_12 = il.append(_factory.createReturn(Type.VOID));
+    method.setMaxStack();
+    method.setMaxLocals();
+    _cg.addMethod(method.getMethod());
+    il.dispose();
+  }
+
+  private void createMethod_1() {
+    InstructionList il = new InstructionList();
+    MethodGen method = new MethodGen(0, new ObjectType("java.lang.Integer"), Type.NO_ARGS, new String[] {  }, "methode", "bcelifier.FieldDeclaration", il, _cp);
+
+    InstructionHandle ih_0 = il.append(_factory.createLoad(Type.OBJECT, 0));
+    il.append(_factory.createFieldAccess("bcelifier.FieldDeclaration", "field", new ObjectType("java.lang.Integer"), Constants.GETFIELD));
+    InstructionHandle ih_4 = il.append(_factory.createReturn(Type.OBJECT));
+    method.setMaxStack();
+    method.setMaxLocals();
+    _cg.addMethod(method.getMethod());
+    il.dispose();
+  }
+
+  public static void main(String[] args) throws Exception {
+    bcelifier.FieldDeclarationCreator creator = new bcelifier.FieldDeclarationCreator();
+    creator.create(new FileOutputStream("bcelifier.FieldDeclaration.class"));
+  }
+}

BCEL/bcelifier/IntLiteral.java

@@ -0,0 +1,7 @@
+package bcelifier;
+
+public class IntLiteral {
+	Integer methode(){
+		return 50000;
+	}
+}

BCEL/bcelifier/IntLiteralCreator.java

@@ -0,0 +1,56 @@
+package bcelifier;
+
+import org.apache.commons.bcel6.generic.*;
+import org.apache.commons.bcel6.classfile.*;
+import org.apache.commons.bcel6.*;
+import java.io.*;
+
+public class IntLiteralCreator implements Constants {
+  private InstructionFactory _factory;
+  private ConstantPoolGen    _cp;
+  private ClassGen           _cg;
+
+  public IntLiteralCreator() {
+    _cg = new ClassGen("bcelifier.IntLiteral", "java.lang.Object", "IntLiteral.java", ACC_PUBLIC | ACC_SUPER, new String[] {  });
+
+    _cp = _cg.getConstantPool();
+    _factory = new InstructionFactory(_cg, _cp);
+  }
+
+  public void create(OutputStream out) throws IOException {
+    createMethod_0();
+    createMethod_1();
+    _cg.getJavaClass().dump(out);
+  }
+
+  private void createMethod_0() {
+    InstructionList il = new InstructionList();
+    MethodGen method = new MethodGen(ACC_PUBLIC, Type.VOID, Type.NO_ARGS, new String[] {  }, "<init>", "bcelifier.IntLiteral", il, _cp);
+
+    InstructionHandle ih_0 = il.append(_factory.createLoad(Type.OBJECT, 0));
+    il.append(_factory.createInvoke("java.lang.Object", "<init>", Type.VOID, Type.NO_ARGS, Constants.INVOKESPECIAL));
+    InstructionHandle ih_4 = il.append(_factory.createReturn(Type.VOID));
+    method.setMaxStack();
+    method.setMaxLocals();
+    _cg.addMethod(method.getMethod());
+    il.dispose();
+  }
+
+  private void createMethod_1() {
+    InstructionList il = new InstructionList();
+    MethodGen method = new MethodGen(0, new ObjectType("java.lang.Integer"), Type.NO_ARGS, new String[] {  }, "methode", "bcelifier.IntLiteral", il, _cp);
+
+    InstructionHandle ih_0 = il.append(new PUSH(_cp, 50000));
+    il.append(_factory.createInvoke("java.lang.Integer", "valueOf", new ObjectType("java.lang.Integer"), new Type[] { Type.INT }, Constants.INVOKESTATIC));
+    InstructionHandle ih_5 = il.append(_factory.createReturn(Type.OBJECT));
+    method.setMaxStack();
+    method.setMaxLocals();
+    _cg.addMethod(method.getMethod());
+    il.dispose();
+  }
+
+  public static void main(String[] args) throws Exception {
+    bcelifier.IntLiteralCreator creator = new bcelifier.IntLiteralCreator();
+    creator.create(new FileOutputStream("bcelifier.IntLiteral.class"));
+  }
+}

BCEL/bcelifier/JavaToBCEL.java

@@ -0,0 +1,42 @@
+package bcelifier;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.nio.file.Files;
+import java.nio.file.OpenOption;
+import java.nio.file.Path;
+
+import  org.apache.commons.bcel6.classfile.ClassFormatException;
+import  org.apache.commons.bcel6.classfile.ClassParser;
+import  org.apache.commons.bcel6.classfile.JavaClass;
+import  org.apache.commons.bcel6.util.BCELifier;
+
+public class JavaToBCEL {
+
+	public final static String rootDirectory = System.getProperty("user.dir")+"/BCEL/bcelifier/";
+	
+	public static void main(String args[]){
+		new JavaToBCEL();
+	}
+	
+	public JavaToBCEL(){
+		try {
+			new BCELifier(new ClassParser(rootDirectory+"Lambda1.class").parse(), new FileOutputStream(new File(rootDirectory+"Lambda1Creator.java"))).start();
+			new BCELifier(new ClassParser(rootDirectory+"This.class").parse(), new FileOutputStream(new File(rootDirectory+"ThisCreator.java"))).start();
+			new BCELifier(new ClassParser(rootDirectory+"IntLiteral.class").parse(), new FileOutputStream(new File(rootDirectory+"IntLiteralCreator.java"))).start();
+			new BCELifier(new ClassParser(rootDirectory+"MethodCall.class").parse(), new FileOutputStream(new File(rootDirectory+"MethodCallCreator.java"))).start();
+			new BCELifier(new ClassParser(rootDirectory+"FieldDeclaration.class").parse(), new FileOutputStream(new File(rootDirectory+"FieldDeclarationCreator.java"))).start();
+			new BCELifier(new ClassParser(rootDirectory+"Null.class").parse(), new FileOutputStream(new File(rootDirectory+"NullCreator.java"))).start();
+			new BCELifier(new ClassParser(rootDirectory+"LocalVarAccess.class").parse(), new FileOutputStream(new File(rootDirectory+"LocalVarAccessCreator.java"))).start();
+			new BCELifier(new ClassParser(rootDirectory+"Wildcard.class").parse(), new FileOutputStream(new File(rootDirectory+"WildcardCreator.java"))).start();
+			new BCELifier(new ClassParser(rootDirectory+"BooleanValue.class").parse(), new FileOutputStream(new File(rootDirectory+"BooleanValueCreator.java"))).start();
+			
+		} catch (ClassFormatException | IOException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	
+}

BCEL/bcelifier/Lambda1.java

@@ -0,0 +1,8 @@
+package bcelifier;
+
+public class Lambda1 {
+
+	Runnable methode(){
+		return ()->System.out.println(this);
+	}
+}

BCEL/bcelifier/Lambda1Creator.java

@@ -0,0 +1,70 @@
+package bcelifier;
+
+import org.apache.commons.bcel6.generic.*;
+import org.apache.commons.bcel6.classfile.*;
+import org.apache.commons.bcel6.*;
+import java.io.*;
+
+public class Lambda1Creator implements Constants {
+  private InstructionFactory _factory;
+  private ConstantPoolGen    _cp;
+  private ClassGen           _cg;
+
+  public Lambda1Creator() {
+    _cg = new ClassGen("bcelifier.Lambda1", "java.lang.Object", "Lambda1.java", ACC_PUBLIC | ACC_SUPER, new String[] {  });
+
+    _cp = _cg.getConstantPool();
+    _factory = new InstructionFactory(_cg, _cp);
+  }
+
+  public void create(OutputStream out) throws IOException {
+    createMethod_0();
+    createMethod_1();
+    createMethod_2();
+    _cg.getJavaClass().dump(out);
+  }
+
+  private void createMethod_0() {
+    InstructionList il = new InstructionList();
+    MethodGen method = new MethodGen(ACC_PUBLIC, Type.VOID, Type.NO_ARGS, new String[] {  }, "<init>", "bcelifier.Lambda1", il, _cp);
+
+    InstructionHandle ih_0 = il.append(_factory.createLoad(Type.OBJECT, 0));
+    il.append(_factory.createInvoke("java.lang.Object", "<init>", Type.VOID, Type.NO_ARGS, Constants.INVOKESPECIAL));
+    InstructionHandle ih_4 = il.append(_factory.createReturn(Type.VOID));
+    method.setMaxStack();
+    method.setMaxLocals();
+    _cg.addMethod(method.getMethod());
+    il.dispose();
+  }
+
+  private void createMethod_1() {
+    InstructionList il = new InstructionList();
+    MethodGen method = new MethodGen(0, new ObjectType("java.lang.Runnable"), Type.NO_ARGS, new String[] {  }, "methode", "bcelifier.Lambda1", il, _cp);
+
+    InstructionHandle ih_0 = il.append(_factory.createLoad(Type.OBJECT, 0));
+    InstructionHandle ih_1 = il.append(_factory.createReturn(Type.OBJECT));
+    method.setMaxStack();
+    method.setMaxLocals();
+    _cg.addMethod(method.getMethod());
+    il.dispose();
+  }
+
+  private void createMethod_2() {
+    InstructionList il = new InstructionList();
+    MethodGen method = new MethodGen(ACC_PRIVATE | ACC_SYNTHETIC, Type.VOID, Type.NO_ARGS, new String[] {  }, "lambda$methode$0", "bcelifier.Lambda1", il, _cp);
+
+    InstructionHandle ih_0 = il.append(_factory.createFieldAccess("java.lang.System", "out", new ObjectType("java.io.PrintStream"), Constants.GETSTATIC));
+    il.append(_factory.createLoad(Type.OBJECT, 0));
+    il.append(_factory.createInvoke("java.io.PrintStream", "println", Type.VOID, new Type[] { Type.OBJECT }, Constants.INVOKEVIRTUAL));
+    InstructionHandle ih_7 = il.append(_factory.createReturn(Type.VOID));
+    method.setMaxStack();
+    method.setMaxLocals();
+    _cg.addMethod(method.getMethod());
+    il.dispose();
+  }
+
+  public static void main(String[] args) throws Exception {
+    bcelifier.Lambda1Creator creator = new bcelifier.Lambda1Creator();
+    creator.create(new FileOutputStream("bcelifier.Lambda1.class"));
+  }
+}

BCEL/bcelifier/LocalVarAccess.java

@@ -0,0 +1,10 @@
+package bcelifier;
+
+public class LocalVarAccess {
+	Integer methode(Integer i){
+		Integer var;
+		var = 10 + i;
+		return var;
+	}
+
+}

BCEL/bcelifier/LocalVarAccessCreator.java

@@ -0,0 +1,61 @@
+package bcelifier;
+
+import org.apache.commons.bcel6.generic.*;
+import org.apache.commons.bcel6.classfile.*;
+import org.apache.commons.bcel6.*;
+import java.io.*;
+
+public class LocalVarAccessCreator implements Constants {
+  private InstructionFactory _factory;
+  private ConstantPoolGen    _cp;
+  private ClassGen           _cg;
+
+  public LocalVarAccessCreator() {
+    _cg = new ClassGen("bcelifier.LocalVarAccess", "java.lang.Object", "LocalVarAccess.java", ACC_PUBLIC | ACC_SUPER, new String[] {  });
+
+    _cp = _cg.getConstantPool();
+    _factory = new InstructionFactory(_cg, _cp);
+  }
+
+  public void create(OutputStream out) throws IOException {
+    createMethod_0();
+    createMethod_1();
+    _cg.getJavaClass().dump(out);
+  }
+
+  private void createMethod_0() {
+    InstructionList il = new InstructionList();
+    MethodGen method = new MethodGen(ACC_PUBLIC, Type.VOID, Type.NO_ARGS, new String[] {  }, "<init>", "bcelifier.LocalVarAccess", il, _cp);
+
+    InstructionHandle ih_0 = il.append(_factory.createLoad(Type.OBJECT, 0));
+    il.append(_factory.createInvoke("java.lang.Object", "<init>", Type.VOID, Type.NO_ARGS, Constants.INVOKESPECIAL));
+    InstructionHandle ih_4 = il.append(_factory.createReturn(Type.VOID));
+    method.setMaxStack();
+    method.setMaxLocals();
+    _cg.addMethod(method.getMethod());
+    il.dispose();
+  }
+
+  private void createMethod_1() {
+    InstructionList il = new InstructionList();
+    MethodGen method = new MethodGen(0, new ObjectType("java.lang.Integer"), new Type[] { new ObjectType("java.lang.Integer") }, new String[] { "arg0" }, "methode", "bcelifier.LocalVarAccess", il, _cp);
+
+    InstructionHandle ih_0 = il.append(new PUSH(_cp, 10));
+    il.append(_factory.createLoad(Type.OBJECT, 1));
+    il.append(_factory.createInvoke("java.lang.Integer", "intValue", Type.INT, Type.NO_ARGS, Constants.INVOKEVIRTUAL));
+    il.append(InstructionConstants.IADD);
+    il.append(_factory.createInvoke("java.lang.Integer", "valueOf", new ObjectType("java.lang.Integer"), new Type[] { Type.INT }, Constants.INVOKESTATIC));
+    il.append(_factory.createStore(Type.OBJECT, 2));
+    InstructionHandle ih_11 = il.append(_factory.createLoad(Type.OBJECT, 2));
+    InstructionHandle ih_12 = il.append(_factory.createReturn(Type.OBJECT));
+    method.setMaxStack();
+    method.setMaxLocals();
+    _cg.addMethod(method.getMethod());
+    il.dispose();
+  }
+
+  public static void main(String[] args) throws Exception {
+    bcelifier.LocalVarAccessCreator creator = new bcelifier.LocalVarAccessCreator();
+    creator.create(new FileOutputStream("bcelifier.LocalVarAccess.class"));
+  }
+}

BCEL/bcelifier/MethodCall.java

@@ -0,0 +1,12 @@
+package bcelifier;
+
+public class MethodCall {
+	void methode(){
+	}
+	
+	void methode2(Runnable r){
+		methode();
+		r.run();
+	}
+}
+

BCEL/bcelifier/MethodCallCreator.java

@@ -0,0 +1,70 @@
+package bcelifier;
+
+import org.apache.commons.bcel6.generic.*;
+import org.apache.commons.bcel6.classfile.*;
+import org.apache.commons.bcel6.*;
+import java.io.*;
+
+public class MethodCallCreator implements Constants {
+  private InstructionFactory _factory;
+  private ConstantPoolGen    _cp;
+  private ClassGen           _cg;
+
+  public MethodCallCreator() {
+    _cg = new ClassGen("bcelifier.MethodCall", "java.lang.Object", "MethodCall.java", ACC_PUBLIC | ACC_SUPER, new String[] {  });
+
+    _cp = _cg.getConstantPool();
+    _factory = new InstructionFactory(_cg, _cp);
+  }
+
+  public void create(OutputStream out) throws IOException {
+    createMethod_0();
+    createMethod_1();
+    createMethod_2();
+    _cg.getJavaClass().dump(out);
+  }
+
+  private void createMethod_0() {
+    InstructionList il = new InstructionList();
+    MethodGen method = new MethodGen(ACC_PUBLIC, Type.VOID, Type.NO_ARGS, new String[] {  }, "<init>", "bcelifier.MethodCall", il, _cp);
+
+    InstructionHandle ih_0 = il.append(_factory.createLoad(Type.OBJECT, 0));
+    il.append(_factory.createInvoke("java.lang.Object", "<init>", Type.VOID, Type.NO_ARGS, Constants.INVOKESPECIAL));
+    InstructionHandle ih_4 = il.append(_factory.createReturn(Type.VOID));
+    method.setMaxStack();
+    method.setMaxLocals();
+    _cg.addMethod(method.getMethod());
+    il.dispose();
+  }
+
+  private void createMethod_1() {
+    InstructionList il = new InstructionList();
+    MethodGen method = new MethodGen(0, Type.VOID, Type.NO_ARGS, new String[] {  }, "methode", "bcelifier.MethodCall", il, _cp);
+
+    InstructionHandle ih_0 = il.append(_factory.createReturn(Type.VOID));
+    method.setMaxStack();
+    method.setMaxLocals();
+    _cg.addMethod(method.getMethod());
+    il.dispose();
+  }
+
+  private void createMethod_2() {
+    InstructionList il = new InstructionList();
+    MethodGen method = new MethodGen(0, Type.VOID, new Type[] { new ObjectType("java.lang.Runnable") }, new String[] { "arg0" }, "methode2", "bcelifier.MethodCall", il, _cp);
+
+    InstructionHandle ih_0 = il.append(_factory.createLoad(Type.OBJECT, 0));
+    il.append(_factory.createInvoke("bcelifier.MethodCall", "methode", Type.VOID, Type.NO_ARGS, Constants.INVOKEVIRTUAL));
+    InstructionHandle ih_4 = il.append(_factory.createLoad(Type.OBJECT, 1));
+    il.append(_factory.createInvoke("java.lang.Runnable", "run", Type.VOID, Type.NO_ARGS, Constants.INVOKEINTERFACE));
+    InstructionHandle ih_10 = il.append(_factory.createReturn(Type.VOID));
+    method.setMaxStack();
+    method.setMaxLocals();
+    _cg.addMethod(method.getMethod());
+    il.dispose();
+  }
+
+  public static void main(String[] args) throws Exception {
+    bcelifier.MethodCallCreator creator = new bcelifier.MethodCallCreator();
+    creator.create(new FileOutputStream("bcelifier.MethodCall.class"));
+  }
+}

BCEL/bcelifier/Null.java

@@ -0,0 +1,7 @@
+package bcelifier;
+
+public class Null {
+
+	Integer i = null;
+	
+}

BCEL/bcelifier/NullCreator.java

@@ -0,0 +1,53 @@
+package bcelifier;
+
+import org.apache.commons.bcel6.generic.*;
+import org.apache.commons.bcel6.classfile.*;
+import org.apache.commons.bcel6.*;
+import java.io.*;
+
+public class NullCreator implements Constants {
+  private InstructionFactory _factory;
+  private ConstantPoolGen    _cp;
+  private ClassGen           _cg;
+
+  public NullCreator() {
+    _cg = new ClassGen("bcelifier.Null", "java.lang.Object", "Null.java", ACC_PUBLIC | ACC_SUPER, new String[] {  });
+
+    _cp = _cg.getConstantPool();
+    _factory = new InstructionFactory(_cg, _cp);
+  }
+
+  public void create(OutputStream out) throws IOException {
+    createFields();
+    createMethod_0();
+    _cg.getJavaClass().dump(out);
+  }
+
+  private void createFields() {
+    FieldGen field;
+
+    field = new FieldGen(0, new ObjectType("java.lang.Integer"), "i", _cp);
+    _cg.addField(field.getField());
+  }
+
+  private void createMethod_0() {
+    InstructionList il = new InstructionList();
+    MethodGen method = new MethodGen(ACC_PUBLIC, Type.VOID, Type.NO_ARGS, new String[] {  }, "<init>", "bcelifier.Null", il, _cp);
+
+    InstructionHandle ih_0 = il.append(_factory.createLoad(Type.OBJECT, 0));
+    il.append(_factory.createInvoke("java.lang.Object", "<init>", Type.VOID, Type.NO_ARGS, Constants.INVOKESPECIAL));
+    InstructionHandle ih_4 = il.append(_factory.createLoad(Type.OBJECT, 0));
+    il.append(InstructionConstants.ACONST_NULL);
+    il.append(_factory.createFieldAccess("bcelifier.Null", "i", new ObjectType("java.lang.Integer"), Constants.PUTFIELD));
+    InstructionHandle ih_9 = il.append(_factory.createReturn(Type.VOID));
+    method.setMaxStack();
+    method.setMaxLocals();
+    _cg.addMethod(method.getMethod());
+    il.dispose();
+  }
+
+  public static void main(String[] args) throws Exception {
+    bcelifier.NullCreator creator = new bcelifier.NullCreator();
+    creator.create(new FileOutputStream("bcelifier.Null.class"));
+  }
+}

BCEL/bcelifier/This.java

@@ -0,0 +1,8 @@
+package bcelifier;
+
+public class This {
+
+	This methode(){
+		return this;
+	}
+}

BCEL/bcelifier/ThisCreator.java

@@ -0,0 +1,55 @@
+package bcelifier;
+
+import org.apache.commons.bcel6.generic.*;
+import org.apache.commons.bcel6.classfile.*;
+import org.apache.commons.bcel6.*;
+import java.io.*;
+
+public class ThisCreator implements Constants {
+  private InstructionFactory _factory;
+  private ConstantPoolGen    _cp;
+  private ClassGen           _cg;
+
+  public ThisCreator() {
+    _cg = new ClassGen("bcelifier.This", "java.lang.Object", "<Unknown>", ACC_PUBLIC | ACC_SUPER, new String[] {  });
+
+    _cp = _cg.getConstantPool();
+    _factory = new InstructionFactory(_cg, _cp);
+  }
+
+  public void create(OutputStream out) throws IOException {
+    createMethod_0();
+    createMethod_1();
+    _cg.getJavaClass().dump(out);
+  }
+
+  private void createMethod_0() {
+    InstructionList il = new InstructionList();
+    MethodGen method = new MethodGen(ACC_PUBLIC, Type.VOID, Type.NO_ARGS, new String[] {  }, "<init>", "bcelifier.This", il, _cp);
+
+    InstructionHandle ih_0 = il.append(_factory.createLoad(Type.OBJECT, 0));
+    il.append(_factory.createInvoke("java.lang.Object", "<init>", Type.VOID, Type.NO_ARGS, Constants.INVOKESPECIAL));
+    InstructionHandle ih_4 = il.append(_factory.createReturn(Type.VOID));
+    method.setMaxStack();
+    method.setMaxLocals();
+    _cg.addMethod(method.getMethod());
+    il.dispose();
+  }
+
+  private void createMethod_1() {
+    InstructionList il = new InstructionList();
+    MethodGen method = new MethodGen(0, new ObjectType("bcelifier.This"), Type.NO_ARGS, new String[] {  }, "methode", "bcelifier.This", il, _cp);
+
+    InstructionHandle ih_0 = il.append(_factory.createLoad(Type.OBJECT, 0));
+    InstructionHandle ih_1 = il.append(_factory.createReturn(Type.OBJECT));
+    method.setMaxStack();
+    method.setMaxLocals();
+    _cg.addMethod(method.getMethod());
+    il.dispose();
+  }
+
+  public static void main(String[] args) throws Exception {
+    bcelifier.ThisCreator creator = new bcelifier.ThisCreator();
+    creator.create(new FileOutputStream("bcelifier.This.class"));
+  }
+}

BCEL/bcelifier/Wildcard.java

@@ -0,0 +1,5 @@
+package bcelifier;
+
+public class Wildcard<A> {
+	Wildcard<? super String> a;
+}

BCEL/bcelifier/WildcardCreator.java

@@ -0,0 +1,50 @@
+package bcelifier;
+
+import org.apache.commons.bcel6.generic.*;
+import org.apache.commons.bcel6.classfile.*;
+import org.apache.commons.bcel6.*;
+import java.io.*;
+
+public class WildcardCreator implements Constants {
+  private InstructionFactory _factory;
+  private ConstantPoolGen    _cp;
+  private ClassGen           _cg;
+
+  public WildcardCreator() {
+    _cg = new ClassGen("bcelifier.Wildcard", "java.lang.Object", "Wildcard.java", ACC_PUBLIC | ACC_SUPER, new String[] {  });
+
+    _cp = _cg.getConstantPool();
+    _factory = new InstructionFactory(_cg, _cp);
+  }
+
+  public void create(OutputStream out) throws IOException {
+    createFields();
+    createMethod_0();
+    _cg.getJavaClass().dump(out);
+  }
+
+  private void createFields() {
+    FieldGen field;
+
+    field = new FieldGen(0, new ObjectType("bcelifier.Wildcard"), "a", _cp);
+    _cg.addField(field.getField());
+  }
+
+  private void createMethod_0() {
+    InstructionList il = new InstructionList();
+    MethodGen method = new MethodGen(ACC_PUBLIC, Type.VOID, Type.NO_ARGS, new String[] {  }, "<init>", "bcelifier.Wildcard", il, _cp);
+
+    InstructionHandle ih_0 = il.append(_factory.createLoad(Type.OBJECT, 0));
+    il.append(_factory.createInvoke("java.lang.Object", "<init>", Type.VOID, Type.NO_ARGS, Constants.INVOKESPECIAL));
+    InstructionHandle ih_4 = il.append(_factory.createReturn(Type.VOID));
+    method.setMaxStack();
+    method.setMaxLocals();
+    _cg.addMethod(method.getMethod());
+    il.dispose();
+  }
+
+  public static void main(String[] args) throws Exception {
+    bcelifier.WildcardCreator creator = new bcelifier.WildcardCreator();
+    creator.create(new FileOutputStream("bcelifier.Wildcard.class"));
+  }
+}

Papers/FMCO2005/main.bbl

@@ -0,0 +1,76 @@
+\begin{thebibliography}{CMP00}
+
+\bibitem[B{\"a}u05]{JB05}
+J{\"o}rg B{\"a}uerle.
+\newblock {\em Typinferenz in \textsf{Java}}.
+\newblock Studienarbeit, BA Stuttgart/Horb, 2005.
+\newblock (in german).
+
+\bibitem[CMP00]{CMP2000}
+Emmanuel Chailloux, Pascal Manoury, and Bruno Pagano.
+\newblock {\em D\'eveloppement d'applications avec Objective Caml}.
+\newblock O'Reilly, avril 2000.
+\newblock in french, translation http://caml.inria.fr/oreilly-book.
+
+\bibitem[Lit98]{VL98}
+Vassily Litvinov.
+\newblock Constraint-based polymorphism in {Cecil}: Towards a practical and
+  static type system.
+\newblock In {\em {OOPSLA} '98 Conference Proceedings}, volume 33(10), pages
+  388--411, 1998.
+
+\bibitem[Mel05]{MM05}
+Markus Melzer.
+\newblock {\em Integration der \textsf{Java}--Typeinferenz in eine
+  Programmierumgebung}.
+\newblock Studienarbeit, BA Stuttgart/Horb, 2005.
+\newblock Studienarbeit (in german).
+
+\bibitem[Ode02]{MO02}
+Martin Odersky.
+\newblock Inferred type instantiation for {GJ}.
+\newblock Note sent to the types mailing list, January 2002.
+
+\bibitem[Ott04]{TO04}
+Thomas Ott.
+\newblock {\em Typinferenz in \textsf{Java}}.
+\newblock Studienarbeit, BA Stuttgart/Horb, 2004.
+\newblock (in german).
+
+\bibitem[OZZ01]{OZZ01}
+Martin Odersky, Christoph Zenger, and Matthias Zenger.
+\newblock Colored local type inference.
+\newblock {\em ACM SIG{\-}PLAN Notices}, 36(3):41--53, 2001.
+
+\bibitem[PC94]{PC94}
+John Plevyak and Andrew~A. Chien.
+\newblock Precise concrete type inference for object-oriented languages.
+\newblock In {\em Proceedings of the ninth annual conference on Object-oriented
+  programming systems, language, and applications}, pages 324--340. ACM Press,
+  1994.
+
+\bibitem[Pl{\"u}04]{Plue04_1}
+Martin Pl{\"u}micke.
+\newblock Type unification in \textsf{Generic--Java}.
+\newblock In Michael Kohlhase, editor, {\em Proceedings of 18th {I}nternational
+  {W}orkshop on {U}nification ({U}{N}{I}{F}'04)}, July 2004.
+\newblock {\tt http://www.faculty.iu-bremen.de/mkohlhase/event/unif04}.
+
+\bibitem[PS91]{PS91}
+Jens Palsberg and Michael~I. Schwartzbach.
+\newblock Object-oriented type inference.
+\newblock {\em Proceedings of OOPSLA'91, ACM SIGPLAN Sixth Annual Conference on
+  Object-Oriented Programming Systems, Languages and Applications}, pages
+  146--161, October 1991.
+
+\bibitem[PS94]{PS94}
+Jens Palsberg and Michael~I. Schwartzbach.
+\newblock {\em Object-oriented type systems}.
+\newblock John Wiley \& Sons, 1994.
+
+\bibitem[PT00]{PT00}
+Benjamin~C. Pierce and David~N. Turner.
+\newblock Local type inference.
+\newblock {\em ACM Trans. Program. Lang. Syst.}, 22(1):1--44, 2000.
+
+\end{thebibliography}

Papers/FMCO2005/main.tex

@@ -0,0 +1,140 @@
+\documentclass[11pt]{article}
+\setlength{\unitlength}{1 true cm}
+\setlength{\oddsidemargin}{0 true mm}
+\setlength{\evensidemargin}{\oddsidemargin}
+\setlength{\textwidth}{160 true mm}
+\setlength{\parindent}{5 true mm}
+\setlength{\topmargin}{1 true mm}
+\setlength{\headheight}{12 true pt}
+\setlength{\headsep}{20 true pt}
+\setlength{\textheight}{240 true mm}
+\setlength{\footskip}{15 true mm}
+\setlength{\voffset}{-10 true mm}
+%\setlength{\footheight}{5 true mm}
+
+\usepackage{prolog}
+
+\title{Type--Inference in \javafive}
+\author{J\"org B\"auerle, Markus Melzer, Martin Pl\"umicke\medskip\\
+\small
+University of Cooperative Education Stuttgart\\
+  %Department of Information Technology\\
+  %Florianstra{\ss}e 15\\
+  %D--72160 Horb\\
+  %tel. +49-7451-521142\\
+  %fax. +49-7451-521190\\
+\small m.pluemicke@ba-horb.de
+}
+
+
+\begin{document}
+\bibliographystyle{alpha}
+\maketitle
+\section{Overview}
+We have developed for \javafive a type inference system. This means that the
+user can write programs without any type annotations and the system determines
+the correct types. We have implemented a prototype for this
+system. Furthermore we have implemented a plugin for the integrated development
+environment \eclipse. 
+
+\section{The Type Inference Algorithm}
+Since then type inference in \oldjava similar languages is known as the
+automatic parameter instantiation in polymorphic methods (local type inference)
+\cite{PT00,OZZ01,MO02}. It is proved that this type inference is
+unsound. Some techniques are presented, which solve these unsoundness.
+
+We extend these approaches to a global variant, where additionally
+the types of method parameters, methods' return types and the
+types of local variables are determined automatically. The input of the algorithm
+are only the types of the fields of the respective classes.
+
+The type inference algorithm traverses the programming code as an abstract syntax
+tree and forms sets of type inequations. As it is known that even the local
+type inference is unsound, it is obvious that our approach is also unsound. We
+deal with this problem, as we allow different type assumptions for the
+parameters, the return type, the local variables, and the expressions of each
+method, respectively. During traversing the set of type assumptions is adapted, such
+that the set contains exactly the assumptions, which are possible assumptions at
+the respective position during the traverse. The adaption is done by solving the
+inequations as far as possible by a type unification algorithm
+\cite{Plue04_1}. The type unification is not unitary but finitary. This means
+that each unification step reduces the set of type assumptions if there is no
+solution for one set of inequations. On the other hand the set of type assumptions is extended, if
+there is more than one solution for a set of inequations.
+
+The result of the type inference algorithm is the set of all correct
+combinations of types of the parameters, the return type, and the local
+variables. 
+
+After the type inference step during the compilation, there are two possibilities. Either for each
+combination of types of each method, byte code could be built,
+respectively. This would lead to the property that method names, which are
+declared only once, could be overloaded.
+On the other hand one combination could
+be selected. Then, for this combination of types byte code would be built. We
+implemented the second possibility (cp. section \ref{sec:IDE}).
+
+Furthermore, we have done comparisons to other type inference
+approaches. We considered the 
+type system of \textsf{Cecil} \cite{VL98}, which is a static type system 
+providing type checking and local type inference. Furthermore we considered a
+type system for a language oriented at \textsf{Smalltalk} \cite{PS91,
+  PS94}. In this approach the types are computed by a least fixed point derivation.
+In \cite{PC94} type inference for the language \textsf{Concurrent Aggregates} is
+described, which contains a data flow analysis. Finally, we considered the type
+system of \textsf{ocaml} \cite{CMP2000}. The approach of this type system
+differs from our's, as  \textsf{ocaml} allows higher-order functions.
+
+\section{Implementation}
+We have done the implementation in \oldjava. The implementation consists of two
+parts. First we describe the implementation of the type unification
+algorithm. Then we present the implementation of the actual type inference via
+code traverse. 
+
+\subsection{Type Unification}
+The implementation of the type unification \cite{TO04} contains as the main
+datastructure a Menge of type term pairs. The algorithm itself is
+implemented as an extension of the usual unification algorithm. Pairs of
+the form $a \olsub ty$ respectively $ty \olsub a$, where $a$ is a variable and
+$ty$ is a term but no variable, generate multiple solutions.
+
+\subsection{Type Inference}
+The idea of the implementation of the actual type inference algorithm
+\cite{JB05} is that each construct in a \javafive program (method, parameter,
+return type, variable,  
+expression) get first a variable as its type assumption. Then, for each variable a
+type is determined by the algorithm.
+
+There are two main datastructures.
+The first one represents type assumptions for methods, fields, and
+variables. During runtime a set of instances of this
+datastructure represent the different possibilities of type assumptions. The
+second main datastructure represents the substitutions of the variables to types,
+calculated step by step.
+
+During runtime each construct of the abstract syntax tree is registered
+as a listener by the corresponding type variable. These registrations finally allow
+to substitute the variables in the abstract syntax tree by the
+calculated types.
+
+\section{Integrated Development Environment (IDE)}
+\label{sec:IDE}
+For \javafive without explicite type declaration a plugin for \eclipse is
+developed \cite{MM05}. The IDE allows to show all different correct
+possibilities to give types to the methods, parameters, return types, and local
+variables, which are determined by the type inference algorithm. Then, the user
+can select the favored type for each construct step by step. Finally, the
+selected types are substituted in the respective constructs of the abstract syntax
+tree. 
+
+\section{Summary and Outlook}
+We have developed a system, which allows to give typeless \javafive
+programs. The system calculates the correct types. The soundness problem is
+solved such that all different possibilities are determined and the user
+himself decides, which type should be used.
+
+In the moment only a subset of \javafive is implemented. Interfaces and
+F--bounded type parameters are not implemented yet. This should be done
+henceforth. 
+\bibliography{martin,SE}
+\end{document}

Papers/FMCO2005/prolog.sty

@@ -0,0 +1,708 @@
+\usepackage{float}
+\usepackage{color}
+\usepackage{xspace_spezial}
+\usepackage{amsmath}
+\usepackage{amssymb}
+\usepackage{alltt}
+\usepackage{fancybox}
+\usepackage{stmaryrd}
+\usepackage{verbatim}
+\usepackage{epsfig}
+\usepackage{multicol}
+\newlength{\textwid}
+\setlength{\textwid}{\textwidth}
+\addtolength{\textwid}{-4ex}
+\newlength{\textfighei}
+\setlength{\textfighei}{\textheight}
+\addtolength{\textfighei}{-10ex}
+\DeclareSymbolFont{blackboard}{OT1}{bbm}{m}{sl}
+\DeclareMathSymbol{\IR}{0}{blackboard}{"52}
+\DeclareMathSymbol{\IN}{0}{blackboard}{"4E}
+\DeclareMathSymbol{\IF}{0}{blackboard}{"46}
+\DeclareMathSymbol{\IP}{0}{blackboard}{"50}
+\DeclareMathSymbol{\IK}{0}{blackboard}{"4D}
+\DeclareMathSymbol{\IZ}{0}{blackboard}{"5A}
+\DeclareMathSymbol{\IQ}{0}{blackboard}{"51}
+\DeclareMathSymbol{\IC}{0}{blackboard}{"43}
+\parindent 0mm
+\renewcommand{\unlhd}{<}
+%\renewcommand{\lhd}{<\!\!|}
+%\renewcommand{\rhd}{|\!\!>}
+\definecolor{blue}{rgb}{0,0,1}
+\definecolor{red}{rgb}{1,0,0}
+\definecolor{green}{rgb}{0,1,0.3}
+\definecolor{bluered}{rgb}{1,0,1}
+\definecolor{bluegreen}{rgb}{1,0.3,0}
+\newcommand{\red}[1]{\textcolor{red}{#1}}
+\newcommand{\blue}[1]{\textcolor{blue}{#1}}
+\newcommand{\green}[1]{\textcolor{green}{#1}}
+\newcommand{\bluered}[1]{\textcolor{bluered}{#1}}
+\newcommand{\bluegreen}[1]{\textcolor{bluegreen}{#1}}
+\reversemarginpar
+\newcommand{\commentary}[1]{\marginpar[\tiny #1]{\tiny #1}}
+%\newcommand{\commentaryforKlaeren}[1]{\marginpar[\tiny #1]{\tiny #1}}
+%\newcommand{\commentary}[1]{}
+\newcommand{\commentaryforKlaeren}[1]{}
+%
+% figure - Einstellungen
+%
+\def\textfraction{0}
+\def\topfraction{1.5}
+\def\bottomfraction{1}
+\def\floatpagefraction{1.0}
+%\def\dbltopfraction{1}
+%\def\dblfloatpagefraction{1.0}
+\newcommand{\indexentry}[2]{\item[] #1 \dotfill #2\qquad\qquad\vspace{-0.8em}}
+\newcommand{\sub}{\textrm{\,$\sqsubseteq$\,}\xspace}
+\newcommand{\nsub}{\text{\,$\not\sqsubseteq$\,}\xspace}
+\newcommand{\ecap}{\mbox{$\,\sqcap\,$}}
+\newcommand{\ecup}{\mbox{$\,\sqcup\,$}}
+\newcommand{\pre}{\mbox{$\,\preceq\,$}}
+\newcommand{\botam}{{\{\, \bot,\ \amalg \,\}}\xspace}
+
+%
+% Substitutions
+%
+\newcommand{\subst}{\textrm{$\expbf{subst}{\normaltset}$}}
+
+%
+% Signaturen
+%
+\def\einf#1#2{\mbox{$(#1,~#2)$}\xspace}
+\newcommand{\sig}{\einf{\normalbtermset}{\Theta}}
+\newcommand{\typesig}{\einf{BTV}{TC}\xspace}
+\newcommand{\einsig}{\einf{\normaltermset}{F}\xspace}
+\newcommand{\msig}{\einsig}
+\newcommand{\mssig}{\einf{\equivtermset}{F_{ms}}\xspace}
+\newcommand{\ossig}{\einf{\normaltset, \sub}{F_{os}}\xspace}
+\def\einfm#1#2{\langle #1,\ #2 \rangle}
+%\def\pos#1#2{\einf{#1,\ \sqsubseteq}{#2}}
+\def\pos#1#2#3{\einf{#1,\ #2}{#3}}
+\def\posm#1#2{\pos{#1}{#2}}
+\def\posSO#1{\pos{#1}{F}}
+\def\posSIG#1{\pos{S}{#1}}
+\newcommand{\posig}{\pos{\normaltset}{\olsub}{\Sigma}}
+\newcommand{\posigM}{\pos{\normaltset}{\olsub}{M}}
+%\newcommand{\posig}{\pos{S}{\Sigma}}
+\newcommand{\overposig}{\pos{\overline{S}}{\overline{\Sigma}}}
+\def\fsf#1#2#3{\mbox{$#1^{(#2,#3)}$}\xspace}
+\def\Sigmaa#1#2{\fsf{F}{#1}{#2}\xspace}
+\newcommand{\Sigmaws}{\Sigmaa{w}{s}}
+\newcommand{\Sigmawt}{\Sigmaa{w}{\theta}}
+\def\set#1{\{\,#1 \,\}}
+\newcommand{\termset}[3]{\textrm{$\exp{#1_{#2}}{#3}$}\xspace}
+\newcommand{\normaltset}{\termset{T}{\Theta}{TV}}
+\newcommand{\normaltermset}{\termset{T}{\Theta}{TV}}
+\newcommand{\normalbtermset}{\termset{T}{TC}{BTV}}
+\newcommand{\equivtermset}{\textrm{$\exp{T_{\Theta_{\sim}}}{TV}$}\xspace}
+\newcommand{\equiva}[1]{[#1]_{\sim}}
+\newcommand{\popoSIG}[1]{\einf{\normaltset,~\sqsubseteq}{#1}}
+\newcommand{\poposig}{\popoSIG{F}}
+%\newcommand{\poss}{polymorphically order-sorted signature\xspace}
+%\newcommand{\posa}{polymorphically order-sorted algebra\xspace}
+\newcommand{\polyosalg}{\textrm{\rm \textbf{PolyOSAlg}$_{\SigO}$}}
+\newcommand{\polyalg}{\textrm{\rm \textbf{PolyAlg}$_{\SigM}$}}
+\newcommand{\SigO}{\textrm{$\Sigma_{\textit{os}}$}\xspace}
+\newcommand{\FuO}{\textrm{$F$}\xspace}
+\newcommand{\SigM}{\textrm{$\Sigma_{\textit{ms}}$}\xspace}
+\newcommand{\FuM}{\textrm{$F$}\xspace}
+\newcommand{\Sig}{\textrm{$\Sigma$}\xspace}
+\newcommand{\SigE}{\textrm{$\Sigma_{\textit{ext}}$}\xspace}
+\newcommand{\objprogram}{\textrm{$<\Sig, \, E>$}\xspace}
+
+%
+% Algebren
+%
+\let\oldsqsubseteq=\sqsubseteq
+\renewcommand{\sqsubseteq}{\leq}
+\def\alg#1#2{\textrm{{\rm (}$#1;#2${\rm )}}\xspace}
+\def\algm#1#2{(#1;#2)}
+\def\algME#1{\alg{#1}{\alpha}}
+\def\algABB#1{\alg{A}{#1}}
+\def\algebra{\alg{A}{\alpha}}
+\def\termalg{\mbox{$\algm{T_{\text{\rm posig}}}{\iota}$}}
+\def\termalgm#1{\algm{T_{\text{#1}}}{\iota_{\text{#1}}}}
+\def\OStermsetvar#1{\textrm{$T_{\SigO}#1$}\xspace}
+\def\OStermset{\OStermsetvar{(V)}}
+\def\OStset{\OStermsetvar{}\xspace}
+\def\OStermsettypevar#1#2{\textrm{$T^{#1}_{\SigO}#2$}\xspace}
+\def\OStermsettype#1{\OStermsettypevar{#1}{(V)}}
+\def\ops{\exp{Ops}{A}}
+\def\exp#1#2{#1(\,#2\,)\xspace}
+%\def\exptt#1#2{\exp{\text{\tt #1}}{\text{\tt #2}}}
+\def\exptt#1#2{\exp{\mbox{$\mathtt{#1}$}}{\mbox{$\mathtt{#2}$}}}
+\def\expsyn#1#2{\exp{\syn{#1}}{\syn{#2}}}
+\def\expbf#1#2{\exp{\text{\bf #1}}{#2}}
+\def\expsf#1#2{\exp{\text{\sf #1}}{#2}}
+\def\exptype#1#2{#1\textrm{{\tt <}}#2\textrm{{\tt >}}\xspace}
+\def\exptypett#1#2{\mathtt{#1}\textrm{{\tt <}}\mathtt{#2}\textrm{{\tt >}}\xspace}
+\def\smalltt#1{\texttt{\small #1}}
+\def\term{\textrm{$\exp{f}{t_1, \ \ldots \ ,t_n}$}\xspace}
+\def\hverbandm#1#2{\textrm{$(#1,~#2)$}}
+\def\partord#1#2{\hverbandm{#1}{#2}\xspace}
+\def\eval#1{eval_{\left<#1\right>}\xspace}
+\def\evalA{$\eval{\algm{A}{\alpha}}$\xspace}
+\def\la#1#2{\mbox{$\lambda#1.#2$}\xspace}
+\def\set#1{\{\, #1 \,\}}
+
+\newcommand{\inletters}[1]{
+  \ifx\the
+  first
+  \fi}
+
+%\newcommand{\olsub}{\textrm{$\, \ol{\sqsubseteq} \,$}\xspace}
+\newcommand{\olsub}{\textrm{$\, \leq^\ast \,$}\xspace}
+\newcommand{\olsubprime}{\textrm{$\, \ol{\sqsubseteq}' \,$}\xspace}
+\newcommand{\nolsub}{\textrm{$\, \not\sqsubseteq^* \,$}\xspace}
+\newcommand{\hverband}{\partord{S}{\sqsubseteq}\xspace}
+\newcommand{\qverband}{\partord{\exp{\ol{T}_{\Theta}}{V}}{\olsub}}
+\newcommand{\cloqverband}{\partord{\exp{T_{\Theta}}{V}}{\olsub}}
+\newcommand{\hord}{\mbox{$(S,~\sqsubseteq)$}\xspace}
+\def\einschr#1{|_{#1}}
+%\newcommand{\lsem}{[\hspace*{-0.3ex}[}
+%\newcommand{\rsem}{]\hspace*{-0.3ex}]}
+\newcommand{\lsem}{\llbracket\hspace{.5ex}}
+\newcommand{\rsem}{\hspace{.5ex}\rrbracket}
+\newcommand{\lsemm}{\lsem}
+\newcommand{\rsemm}{\rsem}
+\newcommand{\semantic}[1]{\lsem #1 \rsem\xspace}
+\newcommand{\ol}[1]{\overline{#1}}
+\newcommand{\ul}[1]{\underline{#1}}
+\newcommand{\dps}{\displaystyle}
+\newcommand{\sema}[3]{{\cal #1}_{#2}\semantic{#3}}
+\newcommand{\sem}[2]{\sema{#1}{}{#2}\xspace}
+
+%
+% Programming languages
+%
+
+\newcommand{\haskell}{\textsf{Haskell}\xspace}
+\newcommand{\gofer}{\textsf{Gofer}\xspace}
+\newcommand{\objp}{\mbox{\textsf{OBJ--P}}\xspace}
+\newcommand{\java}{\mbox{\textsf{G--JAVA}}\xspace}
+\newcommand{\oldjava}{\mbox{\textsf{JAVA}}\xspace}
+\newcommand{\javafive}{\mbox{\textsf{JAVA 5.0}}\xspace}
+\newcommand{\eclipse}{\mbox{\textsf{eclipse}}\xspace}
+\newcommand{\pizza}{\mbox{\textsf{PIZZA}}\xspace}
+\newcommand{\gj}{\mbox{\textsf{GJ}}\xspace}
+\newcommand{\sml}{\mbox{\textsf{SML}}\xspace}
+\newcommand{\ocaml}{\textsf{OCAML}}
+\newcommand{\obj}{\mbox{\textsf{OBJ--3}}\xspace}
+\newcommand{\objtwo}{\mbox{\textsf{OBJ--2}}\xspace}
+
+\def\pot#1{{\cal P}(\, #1 \,)\xspace}
+\def\partf{\overset{\text{\tiny part}}{\longrightarrow}\xspace}
+% 
+% Deduktionssystem
+%
+\newcommand{\byrule}[1]{\raisebox{1.5ex}[0ex][0ex]{{{\rm [{\bf \small #1}]}}}}
+\newcommand{\byruleok}[1]{\raisebox{1.5ex}[0ex][0ex]{{{\rm \small #1}}}}
+\newcommand{\byrulewb}[1]{\raisebox{2.5ex}[0ex][0ex]{{{\rm [{\bf \small #1}]}}}}
+\newcommand{\byruleokwb}[1]{\raisebox{2.5ex}[0ex][0ex]{{{\rm \small #1}}}}
+\newcommand{\byrulesli}[1]{\raisebox{3.0ex}[0ex][0ex]{{{\rm [{\bf \small #1}]}}}}
+\newcommand{\inter}[1]{\bigwedge \hspace{-.55em} \bigwedge_{#1}}
+
+%
+% ARRAY WITH ARGUMENTS
+%
+\newcommand{\sarray}[2]{\begin{array}[t]{#1} #2 \end{array}}
+\newcommand{\sarrayt}[2]{\begin{array}[t]{#1} #2 \end{array}}
+\newcommand{\sarrayb}[2]{\begin{array}[b]{#1} #2 \end{array}}
+\newcommand{\sarrayo}[2]{\begin{array}{#1} #2 \end{array}}
+
+%
+% INFERENCE RULES
+%
+\newcommand{\byrulenew}[1]{\raisebox{2.1ex}[0ex][0ex]{{{\rm [{\bf \small #1}]}}}}
+\newcommand{\postcond}[1]{\raisebox{2.1ex}[0ex][0ex]{#1}}
+\newcommand{\lef}[1]{\multicolumn{1}{@{}l}{#1}}
+\newcommand{\ri}[1]{\multicolumn{1}{r@{}}{#1}}
+\newcommand{\ce}[1]{\multicolumn{1}{@{}c}{#1}}
+\newcommand{\axiom}[2]{\textrm{[}\textbf{\small #1}\textrm{]} & \lef{#2}}
+\newcommand{\irule}[4]{& \sarray{c}{#2}\vspace{1ex}\\\cline{2-2}
+  \vspace{-2ex}\\ \byrulenew{#1} & \sarray{c}{#3} & \postcond{$#4$}}
+\newcommand{\irulealign}[6]{& \sarray{#2}{#3}\vspace{1ex}\\\cline{2-2}
+  \vspace{-2ex}\\ \byrulenew{#1} & \sarray{#4}{#5} & \postcond{$#6$}}
+\newenvironment{irules}{$\begin{array}{lcl}}{\end{array}$}
+
+%
+% Kategorien
+%
+\newcommand{\funs}[1]{\mbox{$F^S_{ERR}$(\, #1 \,)}\xspace}
+\newcommand{\funa}[1]{\mbox{$F^A_{ERR}$(\, #1 \,)}\xspace}
+\newcommand{\funh}[1]{\mbox{$F^H_{ERR}(\, #1 \,)$}\xspace}
+
+%
+% Typherleitungen
+%
+%\let\oldrhd=\rhd
+%\newcommand{\rder}{\hspace*{0.5ex} \rhd_{\textrm{\tiny $\Sig$}} \hspace{0.5ex}}
+\newcommand{\rder}{\hspace*{0.5ex} \rhd \hspace{0.5ex}}
+%\newcommand{\lder}{\hspace*{0.5ex} \lhd_{\textrm{\tiny $\Sig$}} \hspace*{0.5ex}}
+\newcommand{\lder}{\hspace*{0.5ex} \lhd \hspace*{0.5ex}}
+\newcommand{\rderStmt}{\hspace*{0.5ex} \rhd_{Stmt} \hspace*{0.5ex}}
+\newcommand{\rderExpr}{\hspace*{0.5ex} \rhd_{Expr} \hspace*{0.5ex}}
+\newcommand{\rderIdent}{\hspace*{0.5ex} \rhd_{Id} \hspace*{0.5ex}}
+\let\oldblacktriangleright=\blacktriangleright
+%\newcommand{\fder}{\hspace*{1ex} \textrm{$\blacktriangleright_{\textsl{\tiny \hspace{-1ex}\Sig}}$}}
+\newcommand{\fder}{\hspace*{1ex} \textrm{$\blacktriangleright$}}
+
+\newcommand{\newtheo}[3]{\newtheorem{#1}[defhalbordnung]{#2}
+                         \begin{#1} {\rm #3} \label{#1} \end{#1}}
+\newcommand{\der}[2]{\mbox{$#1 \rhd\ #2$}\xspace}
+\newcommand{\derl}[2]{#1 \lhd_{\textrm{\tiny $\Sig$}} #2\xspace}
+\newcommand{\derr}[2]{#1 \rhd_{\textrm{\tiny \hspace{-1ex}$\Sig$}} #2\xspace}
+\newcommand{\derf}[3]{( \, #1, \, #2 \, ) \fder #3\xspace}
+
+\newcommand{\deri}[1]{\der{A}{K}{#1}\xspace}
+\newcommand{\derif}[1]{\derf{A}{K}{D}{#1}\xspace}
+\newcommand{\arity}[3]{\textrm{$\alpha^{(#1,#2)}_{#3}$}\xspace}
+\newcommand{\coarity}[2]{\textrm{$\beta^{(#1,#2)}$}\xspace}
+\newcommand{\sodaprg}{\textrm{$(\,\textsl{csig},\ D\,)$\xspace}}
+
+%
+% Typen
+%
+\newcommand{\typ}[3]{\textrm{$ #1 \times \ldots \times #2 \rightarrow #3$}\xspace}
+\newcommand{\syn}[1]{{\rm \texttt{\small #1}}}
+\newcommand{\sigmatyp}{\typ{\sigma_1}{\sigma_n}{\sigma}\xspace}
+\newcommand{\sigmadef}{\mbox{$\sigma_1 \times \ldots \times \sigma_n$}\xspace}
+\newcommand{\tautyp}{\typ{\tau_1}{\tau_n}{\tau}\xspace}
+\newcommand{\tautypsup}[1]{\typ{\tau^{#1}_1}{\tau^{#1}_n}{\tau^{#1}}\xspace}
+\newcommand{\taudef}{\mbox{$\tau_1 \times \ldots \times \tau_n$}\xspace}
+\newcommand{\thetatyp}{\typ{\theta_1}{\theta_n}{\theta_0}\xspace}
+\newcommand{\type}{\text{$\text{TYPE}(\,S,\ V\,)$}\xspace}
+\newcommand{\typea}{\text{$\text{TYPE}_T(\,S,\ V\,)$}\xspace}
+\newcommand{\ptype}{{\rm \expsf{Type}{\normalbtermset}}\xspace}
+\newcommand{\ptypea}{\text{$\text{TYPE}_T(\,\Theta,\ V\,)$}\xspace}
+\newcommand{\types}{\text{$\text{TYPE}_s(\,S,\ \Gamma\,)$}\xspace}
+
+\newcommand{\epsbox}[2]{
+  %\begin{center}
+    \setlength{\fboxsep}{4mm}
+    \fbox{\epsfxsize=#1 \epsfbox{#2}}
+  %\end{center}
+    }
+
+\newcommand{\epsxybox}[3]{
+  \begin{minipage}[t]{#1}
+    \setlength{\fboxsep}{4mm}
+    \fbox{\epsfysize=#2 \epsfbox{#3}}
+  \end{minipage}}
+
+\newenvironment{program}{\begin{alltt}\small}
+               {\normalsize\end{alltt}\vspace*{-1em}}
+\floatstyle{plain}
+\newfloat{soda}{htp}{lop}
+\floatname{soda}{SODA-Program}
+
+%\sodaprog
+% 1. width
+% 2. figure
+% 3. file
+\newcommand{\sodaprog}[3]{
+  \begin{figure}%[#2]
+    %\begin{center}
+      \begin{Sbox}
+        \begin{minipage}{#1}
+          \small
+          \begin{alltt}
+            \verbatiminput{#3.soda}
+          \end{alltt}
+          \normalsize
+        \end{minipage}
+      \end{Sbox}
+      \setlength{\fboxsep}{2mm}
+      \fbox{\TheSbox}
+    %\end{center}
+    \caption{SODA module \texttt{#3}}
+    \label{fig:#3}
+  \end{figure}
+  }
+
+%
+% Theorem
+%
+\newcommand{\QED}{\rule{1.1ex}{1.1ex}}
+%\newenvironment{proof}{\par \bigskip \noindent {\bf Proof:}
+%          }{\mbox{ } \hfill \QED \par \smallskip}
+%\newenvironment{remark}{\par \bigskip \noindent {\bf Remark}
+%          }{\par \smallskip}
+%\newtheorem{definition}{Definition}[section]
+%\newtheorem{example}[definition]{Example}
+%\newtheorem{theorem}[definition]{Theorem}
+%\newtheorem{corollary}[definition]{Corollary}
+%\newtheorem{lemma}[definition]{Lemma}
+%\newtheorem{algorithm}[definition]{Algorithm}
+%\newenvironment{abstract}{\small \begin{center} {\bf Abstract}\\[2ex]
+  %\begin{minipage}{0.85\textwidth}}{\end{minipage} \end{center}}
+\newenvironment{Zusammenfassung}{\small \begin{center} {\bf Zusammenfassung}\\[2ex]
+  \begin{minipage}{0.85\textwidth}}{\end{minipage} \end{center}}
+\newlength{\level}
+\newlength{\wid}
+
+
+%\newcommand{\thelb}{
+\def\notunlhd{\mathrel{\unlhd\!\!\!\!\!\mid}}
+\def\In#1#2{#1 \! \in \! #2}
+\def\Leq#1#2#3{#1 \! \leqslant \! #2 \! \leqslant \! #3}
+\def\Lequ#1#2#3{#1 \leqslant #2 \leqslant #3}
+\newcommand{\ma}[1]{\text{``}#1\text{''}\xspace}
+\newcommand{\ttm}[1]{\mbox{\tt #1}\xspace}
+\newcommand{\ret}[2]{\ttm{r}^{\ttm{\footnotesize #1}}_{\ttm{\footnotesize #2}}\xspace}
+\newcommand{\retm}[2]{\ttm{r}^{#1}_{#2}\xspace}
+\newcommand{\re}[2]{\displaystyle r^{#1}_{#2}\xspace}
+\newlength{\qwert}
+%\newcommand{\htext}[1]{\settowidth{\qwert}{#1} \addtolength{\qwert}{-0.65ex} \hspace*{\qwert}}
+\newcommand{\htext}[1]{\settowidth{\qwert}{#1} \hspace*{\qwert}}
+\newcommand{\leng}[1]{\settowidth{\qwert}{#1} \qwert}
+\newcommand{\ldo}{, \ldots , }
+
+
+%
+% Algorithmus
+%
+\newcommand{\nll}{\newline\hspace*{\level}}
+\newcommand{\nlevel}{\addtolength{\level}{0.4cm}}
+\newcommand{\llevel}{\addtolength{\level}{-0.4cm}}
+\newcommand{\ifc}[1]{\textbf{if} \nlevel #1 \llevel}
+\newcommand{\elsifc}[1]{\textbf{elsif} \nlevel #1 \llevel}
+\newcommand{\foreachc}[2]{\textbf{foreach} #1 \nlevel #2 \llevel}
+\newcommand{\thenc}[1]{\textbf{then} \nlevel #1 \llevel}
+\newcommand{\ifthenc}[2]{\textbf{if} #1 \textbf{then} \nlevel #2 \llevel}
+\newcommand{\elsec}[1]{\textbf{else} \nlevel #1 \llevel}
+\newcommand{\eifc}{\textbf{endif}\\}
+\newcommand{\casec}[2]{\fbox{\textbf{case} #1}\ \nlevel \nlevel #2 \llevel \llevel}
+\newcommand{\letc}[2]{\textbf{let} \nlevel \\ #1 = \nlevel #2 \llevel \llevel}
+\newcommand{\letbf}[1]{\textbf{let} \nlevel \\ #1 \llevel}
+\newcommand{\inc}[1]{\textbf{in} \nlevel #1 \llevel \nopagebreak\\ \textbf{end}}
+\newcommand{\lam}[2]{\textbf{fn } #1 \textrm{$\, \Rightarrow \,$} #2}
+\newcommand{\inputc}[1]{\nll \textbf{Input:} \nlevel #1 \llevel}
+\newcommand{\outputc}[1]{\nll \textbf{Output:} \nlevel #1 \llevel}
+%\newcommand{\letforeachc}[3]{\textbf{let-foreach} \nlevel #1:\\ \ul{#2} = \nlevel #3 \llevel \llevel}
+\newcommand{\letforeachc}[3]{\textbf{let-foreach} \nlevel #1:\\ #2 = \nlevel #3 \llevel \llevel}
+%\newcommand{\letuc}[2]{\textbf{let} \nlevel \\ \ul{#1} = \nlevel #2 \llevel \llevel}
+\newcommand{\letuc}[2]{\textbf{let} \nlevel \\ #1 = \nlevel #2 \llevel \llevel}
+\newcommand{\letoeq}[3]{\textbf{let} \nlevel \\ #1 #2 \nlevel #3 \llevel \llevel}
+\newcommand{\letoeqol}[3]{\nlevel \\ #1 #2 \nlevel #3 \llevel \llevel}
+%\newcommand{\letu}[2]{\nlevel\\ \ul{#1} = \nlevel #2 \llevel\llevel}
+\newcommand{\letu}[2]{\nlevel\\ #1 = \nlevel #2 \llevel\llevel}
+\newcommand{\letnc}[2]{\nlevel\\ #1 = \nlevel #2 \llevel\llevel}
+\newcommand{\misc}[1]{\nlevel\\ #1 \llevel}
+\newcommand{\least}{\textrm{$\top$}\xspace}
+\newenvironment{algocommands}{
+ \setlength{\level}{2mm}
+ \renewcommand{\\}{\nll}
+ \noindent
+ }{\renewcommand{\\}{\newline}
+ \vspace{1ex}
+  }
+\newenvironment{algo}{\begin{algorithm} \rm %\mbox{}\\
+    \begin{algocommands}
+ }{\end{algocommands}
+ \end{algorithm}
+  }
+
+\newenvironment{boxedalgo}{
+  \begin{Sbox}
+    \begin{minipage}{\textwid}
+      \begin{algo}
+        }{\end{algo}
+    \end{minipage}
+  \end{Sbox}
+  \fbox{\TheSbox}
+  }
+
+\newenvironment{Liste}{\begin{list}{\textbf{--}}{
+      \setlength{\parsep}{0pt plus0.0ex}
+      \setlength{\labelwidth}{2ex}
+      \setlength{\itemsep}{0pt}
+      \setlength{\leftmargin}{\labelsep +\labelwidth}
+    }}{\normalsize \end{list}}
+
+
+\newcounter{ficall}
+\setcounter{ficall}{0}
+\newcommand{\ficall}[1]{\addtocounter{ficall}{1}\subsubsection*{(\theficall) \
+    #1}
+\setcounter{secall}{0}
+\setcounter{thicall}{0}
+\setcounter{focall}{0}
+\setcounter{fifcall}{0}
+\setcounter{sixcall}{0}
+\setcounter{sevcall}{0}
+\setcounter{eigcall}{0}
+\setcounter{nicall}{0}
+\setcounter{tencall}{0}
+\setcounter{elecall}{0}
+}
+\newcommand{\reficall}[1]{\subsubsection*{(\theficall) \
+    #1}}
+\newcounter{fifinum}
+\newcommand{\finumset}{\setcounter{fifinum}{\value{ficall}}}
+\newcommand{\finum}{\thefifinum}
+\newcounter{fifinumold}
+\newcommand{\finumoldset}{
+  \setcounter{fifinumold}{\value{fifinum}}
+}
+\newcommand{\finumold}{\thesefinumold}
+
+\newcounter{secall}
+\setcounter{secall}{0}
+\newcounter{sefinum}\newcounter{sesenum}
+\newcommand{\senumset}{\setcounter{sefinum}{\value{ficall}}\setcounter{sesenum}{\value{secall}}}
+\newcommand{\secall}[1]{\addtocounter{secall}{1}\subsubsection*{(\theficall.\thesecall) \ #1}
+\setcounter{thicall}{0}
+\setcounter{focall}{0}
+\setcounter{fifcall}{0}
+\setcounter{sixcall}{0}
+\setcounter{sevcall}{0}
+\setcounter{eigcall}{0}
+\setcounter{nicall}{0}
+\setcounter{tencall}{0}
+\setcounter{elecall}{0}
+}
+\newcommand{\resecall}[1]{\subsubsection*{(\theficall.\thesecall) \ #1}}
+\newcommand{\senum}{\thesefinum.\thesesenum}
+\newcounter{sefinumold}
+\newcounter{sesenumold}
+\newcommand{\senumoldset}{
+  \setcounter{sefinumold}{\value{sefinum}}
+  \setcounter{sesenumold}{\value{sesenum}}
+}
+\newcommand{\senumold}{\thesefinumold.\thesesenumold}
+
+\newcounter{thicall}
+\setcounter{thicall}{0}
+\newcounter{thifinum}\newcounter{thisenum}\newcounter{thithinum}
+\newcommand{\thinumset}{\setcounter{thifinum}{\value{ficall}}\setcounter{thisenum}{\value{secall}}\setcounter{thithinum}{\value{thicall}}}
+\newcommand{\thicall}[1]{\addtocounter{thicall}{1}\subsubsection*{(\theficall.\thesecall.\thethicall) \ #1}
+\setcounter{focall}{0}
+\setcounter{fifcall}{0}
+\setcounter{sixcall}{0}
+\setcounter{sevcall}{0}
+\setcounter{eigcall}{0}
+\setcounter{nicall}{0}
+\setcounter{tencall}{0}
+\setcounter{elecall}{0}
+}
+\newcommand{\rethicall}[1]{\subsubsection*{(\theficall.\thesecall.\thethicall) \ #1}}
+\newcommand{\thinum}{\thethifinum.\thethisenum.\thethithinum}
+
+\newcounter{focall}
+\setcounter{focall}{0}
+\newcounter{fofinum}\newcounter{fosenum}\newcounter{fothinum}\newcounter{fofonum}
+\newcommand{\focall}[1]{\addtocounter{focall}{1}\subsubsection*{(\theficall.\thesecall.\thethicall.\thefocall) \ #1}
+\setcounter{fifcall}{0}
+\setcounter{sixcall}{0}
+\setcounter{sevcall}{0}
+\setcounter{eigcall}{0}
+\setcounter{nicall}{0}
+\setcounter{tencall}{0}
+\setcounter{elecall}{0}
+}
+\newcommand{\fonumset}{\setcounter{fofinum}{\value{ficall}}\setcounter{fosenum}{\value{secall}}\setcounter{fothinum}{\value{thicall}}\setcounter{fofonum}{\value{focall}}}
+\newcommand{\fonum}{\thefofinum.\thefosenum.\thefothinum.\thefofonum}
+\newcommand{\refocall}[1]{\subsubsection*{(\theficall.\thesecall.\thethicall.\thefocall) \ #1}}
+
+\newcounter{fifcall}
+\setcounter{fifcall}{0}
+\newcommand{\fifcall}[1]{\addtocounter{fifcall}{1}\subsubsection*{(\theficall.\thesecall.\thethicall.\thefocall.\thefifcall) \ #1}
+\setcounter{sixcall}{0}
+\setcounter{sevcall}{0}
+\setcounter{eigcall}{0}
+\setcounter{nicall}{0}
+\setcounter{tencall}{0}
+\setcounter{elecall}{0}
+}
+\newcounter{fiffinum}\newcounter{fifsenum}\newcounter{fifthinum}\newcounter{fiffonum}\newcounter{fiffifnum}
+\newcommand{\fifnumset}{\setcounter{fiffinum}{\value{ficall}}\setcounter{fifsenum}{\value{secall}}\setcounter{fifthinum}{\value{thicall}}\setcounter{fiffonum}{\value{focall}}\setcounter{fiffifnum}{\value{fifcall}}}
+\newcommand{\fifnum}{\thefiffinum.\thefifsenum.\thefifthinum.\thefiffonum.\thefiffifnum}
+\newcommand{\refifcall}[1]{\subsubsection*{(\theficall.\thesecall.\thethicall.\thefocall.\thefifcall) \ #1}}
+\newcounter{fiffinumold}
+\newcounter{fifsenumold}
+\newcounter{fifthinumold}
+\newcounter{fiffonumold}
+\newcounter{fiffifnumold}
+\newcommand{\fifnumoldset}{
+  \setcounter{fiffinumold}{\value{fiffinum}}
+  \setcounter{fifsenumold}{\value{fifsenum}}
+  \setcounter{fifthinumold}{\value{fifthinum}}
+  \setcounter{fiffonumold}{\value{fiffonum}}
+  \setcounter{fiffifnumold}{\value{fiffifnum}}
+}
+\newcommand{\fifnumold}{\thefiffinumold.\thefifsenumold.\thefifthinumold.\thefiffonumold.\thefiffifnumold}
+
+\newcounter{fiffinumoldold}
+\newcounter{fifsenumoldold}
+\newcounter{fifthinumoldold}
+\newcounter{fiffonumoldold}
+\newcounter{fiffifnumoldold}
+\newcommand{\fifnumoldoldset}{
+  \setcounter{fiffinumoldold}{\value{fiffinum}}
+  \setcounter{fifsenumoldold}{\value{fifsenum}}
+  \setcounter{fifthinumoldold}{\value{fifthinum}}
+  \setcounter{fiffonumoldold}{\value{fiffonum}}
+  \setcounter{fiffifnumoldold}{\value{fiffifnum}}
+}
+\newcommand{\fifnumoldold}{\thefiffinumoldold.\thefifsenumoldold.\thefifthinumoldold.\thefiffonumoldold.\thefiffifnumoldold}
+
+\newcounter{sixcall}
+\setcounter{sixcall}{0}
+\newcommand{\sixcall}[1]{\addtocounter{sixcall}{1}\subsubsection*{(\theficall.\thesecall.\thethicall.\thefocall.\thefifcall.\thesixcall) \ #1}
+\setcounter{sevcall}{0}
+\setcounter{eigcall}{0}
+\setcounter{nicall}{0}
+\setcounter{tencall}{0}
+\setcounter{elecall}{0}
+}
+\newcounter{sixfinum}
+\newcounter{sixsenum}
+\newcounter{sixthinum}
+\newcounter{sixfonum}
+\newcounter{sixfifnum}
+\newcounter{sixsixnum}
+\newcommand{\sixnumset}{
+  \setcounter{sixfinum}{\value{ficall}}
+  \setcounter{sixsenum}{\value{secall}}
+  \setcounter{sixthinum}{\value{thicall}}
+  \setcounter{sixfonum}{\value{focall}}
+  \setcounter{sixfifnum}{\value{fifcall}}
+  \setcounter{sixsixnum}{\value{sixcall}}
+  }
+\newcommand{\sixnum}{\thesixfinum.\thesixsenum.\thesixthinum.\thesixfonum.\thesixfifnum.\thesixsixnum}
+\newcommand{\resixcall}[1]{\subsubsection*{(\theficall.\thesecall.\thethicall.\thefocall.\thefifcall.\thesixcall) \ #1}}
+
+\newcounter{sevcall}
+\setcounter{sevcall}{0}
+\newcommand{\sevcall}[1]{\addtocounter{sevcall}{1}\subsubsection*{(\theficall.\thesecall.\thethicall.\thefocall.\thefifcall.\thesixcall.\thesevcall) \ #1}
+\setcounter{eigcall}{0}
+\setcounter{nicall}{0}
+\setcounter{tencall}{0}
+\setcounter{elecall}{0}
+}
+\newcounter{sevfinum}
+\newcounter{sevsenum}
+\newcounter{sevthinum}
+\newcounter{sevfonum}
+\newcounter{sevfifnum}
+\newcounter{sevsixnum}
+\newcounter{sevsevnum}
+\newcommand{\sevnumset}{
+  \setcounter{sevfinum}{\value{ficall}}
+  \setcounter{sevsenum}{\value{secall}}
+  \setcounter{sevthinum}{\value{thicall}}
+  \setcounter{sevfonum}{\value{focall}}
+  \setcounter{sevfifnum}{\value{fifcall}}
+  \setcounter{sevsixnum}{\value{sixcall}}
+  \setcounter{sevsevnum}{\value{sevcall}}
+  }
+\newcommand{\sevnum}{\thesevfinum.\thesevsenum.\thesevthinum.\thesevfonum.\thesevfifnum.\thesevsixnum.\thesevsevnum}
+\newcommand{\resevcall}[1]{\subsubsection*{(\theficall.\thesecall.\thethicall.\thefocall.\thefifcall.\thesixcall.\thesevcall) \ #1}}
+
+\newcounter{eigcall}
+\newcounter{eigfinum}\newcounter{eigsenum}\newcounter{eigthinum}\newcounter{eigfonum}\newcounter{eigfifnum}\newcounter{eigsixnum}\newcounter{eigsevnum}\newcounter{eigeignum}
+\setcounter{eigcall}{0}
+\newcommand{\eignumset}{\setcounter{eigfinum}{\value{ficall}}\setcounter{eigsenum}{\value{secall}}\setcounter{eigthinum}{\value{thicall}}\setcounter{eigfonum}{\value{focall}}\setcounter{eigfifnum}{\value{fifcall}}\setcounter{eigsixnum}{\value{sixcall}}\setcounter{eigsevnum}{\value{sevcall}}\setcounter{eigeignum}{\value{eigcall}}}
+\newcommand{\eignum}{\theeigfinum.\theeigsenum.\theeigthinum.\theeigfonum.\theeigfifnum.\theeigsixnum.\theeigsevnum.\theeigeignum}
+\newcommand{\eigcall}[1]{\addtocounter{eigcall}{1}\subsubsection*{(\theficall.\thesecall.\thethicall.\thefocall.\thefifcall.\thesixcall.\thesevcall.\theeigcall) \ #1}
+\setcounter{nicall}{0}
+\setcounter{tencall}{0}
+\setcounter{elecall}{0}
+}
+\newcommand{\reeigcall}[1]{\subsubsection*{(\theficall.\thesecall.\thethicall.\thefocall.\thefifcall.\thesixcall.\thesevcall.\theeigcall) \ #1}}
+
+\newcounter{nicall}
+\newcounter{nifinum}\newcounter{nisenum}\newcounter{nithinum}\newcounter{nifonum}\newcounter{nififnum}\newcounter{nisixnum}\newcounter{nisevnum}\newcounter{nieignum}\newcounter{nininum}
+\setcounter{nicall}{0}
+\newcommand{\ninumset}{\setcounter{nifinum}{\value{ficall}}\setcounter{nisenum}{\value{secall}}\setcounter{nithinum}{\value{thicall}}\setcounter{nifonum}{\value{focall}}\setcounter{nififnum}{\value{fifcall}}\setcounter{nisixnum}{\value{sixcall}}\setcounter{nisevnum}{\value{sevcall}}\setcounter{nieignum}{\value{eigcall}}\setcounter{nininum}{\value{nicall}}}
+\newcommand{\ninum}{\thenifinum.\thenisenum.\thenithinum.\thenifonum.\thenififnum.\thenisixnum.\thenisevnum.\thenieignum.\thenininum}
+\newcommand{\nicall}[1]{\addtocounter{nicall}{1}\subsubsection*{(\theficall.\thesecall.\thethicall.\thefocall.\thefifcall.\thesixcall.\thesevcall.\theeigcall.\thenicall)
+    \ #1}
+\setcounter{tencall}{0}
+\setcounter{elecall}{0}
+}
+\newcommand{\renicall}[1]{\subsubsection*{(\theficall.\thesecall.\thethicall.\thefocall.\thefifcall.\thesixcall.\thesevcall.\theeigcall.\thenicall)
+    \ #1}}
+\newcounter{nifinumold}
+\newcounter{nisenumold}
+\newcounter{nithinumold}
+\newcounter{nifonumold}
+\newcounter{nififnumold}
+\newcounter{nisixnumold}
+\newcounter{nisevnumold}
+\newcounter{nieignumold}
+\newcounter{nininumold}
+\newcommand{\ninumoldset}{
+  \setcounter{nifinumold}{\value{nifinum}}
+  \setcounter{nisenumold}{\value{nisenum}}
+  \setcounter{nithinumold}{\value{nithinum}}
+  \setcounter{nifonumold}{\value{nifonum}}
+  \setcounter{nififnumold}{\value{nififnum}}
+  \setcounter{nisixnumold}{\value{nisixnum}}
+  \setcounter{nisevnumold}{\value{nisevnum}}
+  \setcounter{nieignumold}{\value{nieignum}}
+  \setcounter{nininumold}{\value{nininum}}
+}
+\newcommand{\ninumold}{\thenifinumold.\thenisenumold.\thenithinumold.\thenifonumold.\thenififnumold.\thenisixnumold.\thenisevnumold.\thenieignumold.\thenininumold}
+
+
+\newcounter{tencall}
+\setcounter{tencall}{0}
+\newcommand{\tencall}[1]{\addtocounter{tencall}{1}\subsubsection*{(\theficall.\thesecall.\thethicall.\thefocall.\thefifcall.\thesixcall.\thesevcall.\theeigcall.\thenicall.\thetencall)
+    \ #1}
+\setcounter{elecall}{0}
+}
+\newcommand{\retencall}[1]{\subsubsection*{(\theficall.\thesecall.\thethicall.\thefocall.\thefifcall.\thesixcall.\thesevcall.\theeigcall.\thenicall.\thetencall)
+    \ #1}}
+\newcounter{tenfinum}
+\newcounter{tensenum}
+\newcounter{tenthinum}
+\newcounter{tenfonum}
+\newcounter{tenfifnum}
+\newcounter{tensixnum}
+\newcounter{tensevnum}
+\newcounter{teneignum}
+\newcounter{tenninum}
+\newcounter{tentennum}
+\newcommand{\tennumset}{
+  \setcounter{tenfinum}{\value{ficall}}
+  \setcounter{tensenum}{\value{secall}}
+  \setcounter{tenthinum}{\value{thicall}}
+  \setcounter{tenfonum}{\value{focall}}
+  \setcounter{tenfifnum}{\value{fifcall}}
+  \setcounter{tensixnum}{\value{sixcall}}
+  \setcounter{tensevnum}{\value{sevcall}}
+  \setcounter{teneignum}{\value{eigcall}}
+  \setcounter{tenninum}{\value{nicall}}
+  \setcounter{tentennum}{\value{tencall}}}
+\newcommand{\tennum}{\thetenfinum.\thetensenum.\thetenthinum.\thetenfonum.\thetenfifnum.\thetensixnum.\thetensevnum.\theteneignum.\thetenninum.\thetentennum}
+
+\newcounter{elecall}
+\setcounter{elecall}{0}
+\newcommand{\elecall}[1]{\addtocounter{elecall}{1}\subsubsection*{(\theficall.\thesecall.\thethicall.\thefocall.\thefifcall.\thesixcall.\thesevcall.\theeigcall.\thenicall.\thetencall.\theelecall) \ #1}}
+\newcounter{elefinum}
+\newcounter{elesenum}
+\newcounter{elethinum}
+\newcounter{elefonum}
+\newcounter{elefifnum}
+\newcounter{elesixnum}
+\newcounter{elesevnum}
+\newcounter{eleeignum}
+\newcounter{eleninum}
+\newcounter{eletennum}
+\newcounter{eleelenum}
+\newcommand{\elenumset}{
+  \setcounter{elefinum}{\value{ficall}}
+  \setcounter{elesenum}{\value{secall}}
+  \setcounter{elethinum}{\value{thicall}}
+  \setcounter{elefonum}{\value{focall}}
+  \setcounter{elefifnum}{\value{fifcall}}
+  \setcounter{elesixnum}{\value{sixcall}}
+  \setcounter{elesevnum}{\value{sevcall}}
+  \setcounter{eleeignum}{\value{eigcall}}
+  \setcounter{eleninum}{\value{nicall}}
+  \setcounter{eletennum}{\value{tencall}}
+  \setcounter{eleelenum}{\value{elecall}}
+  }
+\newcommand{\elenum}{\theelefinum.\theelesenum.\theelethinum.\theelefonum.\theelefifnum.\theelesixnum.\theelesevnum.\theeleeignum.\theeleninum.\theeletennum.\theeleelenum}

TODO.md

@@ -0,0 +1,2 @@
+Nächste Aufgaben:
+

antlr/Java8.tokens

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

antlr/Java8Lexer.java

@@ -0,0 +1,515 @@
+// Generated from Java8.g4 by ANTLR 4.4
+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.4", 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, ADD_ASSIGN=89, 
+		SUB_ASSIGN=90, MUL_ASSIGN=91, DIV_ASSIGN=92, AND_ASSIGN=93, OR_ASSIGN=94, 
+		XOR_ASSIGN=95, MOD_ASSIGN=96, LSHIFT_ASSIGN=97, RSHIFT_ASSIGN=98, URSHIFT_ASSIGN=99, 
+		Identifier=100, AT=101, ELLIPSIS=102, WS=103, COMMENT=104, LINE_COMMENT=105;
+	public static String[] modeNames = {
+		"DEFAULT_MODE"
+	};
+
+	public static final String[] tokenNames = {
+		"'\\u0000'", "'\\u0001'", "'\\u0002'", "'\\u0003'", "'\\u0004'", "'\\u0005'", 
+		"'\\u0006'", "'\\u0007'", "'\b'", "'\t'", "'\n'", "'\\u000B'", "'\f'", 
+		"'\r'", "'\\u000E'", "'\\u000F'", "'\\u0010'", "'\\u0011'", "'\\u0012'", 
+		"'\\u0013'", "'\\u0014'", "'\\u0015'", "'\\u0016'", "'\\u0017'", "'\\u0018'", 
+		"'\\u0019'", "'\\u001A'", "'\\u001B'", "'\\u001C'", "'\\u001D'", "'\\u001E'", 
+		"'\\u001F'", "' '", "'!'", "'\"'", "'#'", "'$'", "'%'", "'&'", "'''", 
+		"'('", "')'", "'*'", "'+'", "','", "'-'", "'.'", "'/'", "'0'", "'1'", 
+		"'2'", "'3'", "'4'", "'5'", "'6'", "'7'", "'8'", "'9'", "':'", "';'", 
+		"'<'", "'='", "'>'", "'?'", "'@'", "'A'", "'B'", "'C'", "'D'", "'E'", 
+		"'F'", "'G'", "'H'", "'I'", "'J'", "'K'", "'L'", "'M'", "'N'", "'O'", 
+		"'P'", "'Q'", "'R'", "'S'", "'T'", "'U'", "'V'", "'W'", "'X'", "'Y'", 
+		"'Z'", "'['", "'\\'", "']'", "'^'", "'_'", "'`'", "'a'", "'b'", "'c'", 
+		"'d'", "'e'", "'f'", "'g'", "'h'", "'i'"
+	};
+	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", "DigitOrUnderscore", 
+		"Underscores", "HexNumeral", "HexDigits", "HexDigit", "HexDigitOrUnderscore", 
+		"OctalNumeral", "OctalDigits", "OctalDigit", "OctalDigitOrUnderscore", 
+		"BinaryNumeral", "BinaryDigits", "BinaryDigit", "BinaryDigitOrUnderscore", 
+		"FloatingPointLiteral", "DecimalFloatingPointLiteral", "ExponentPart", 
+		"ExponentIndicator", "SignedInteger", "Sign", "FloatTypeSuffix", "HexadecimalFloatingPointLiteral", 
+		"HexSignificand", "BinaryExponent", "BinaryExponentIndicator", "BooleanLiteral", 
+		"CharacterLiteral", "SingleCharacter", "StringLiteral", "StringCharacters", 
+		"StringCharacter", "EscapeSequence", "OctalEscape", "UnicodeEscape", "ZeroToThree", 
+		"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", "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"
+	};
+
+
+	public Java8Lexer(CharStream input) {
+		super(input);
+		_interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
+	}
+
+	@Override
+	public String getGrammarFileName() { return "Java8.g4"; }
+
+	@Override
+	public String[] getTokenNames() { return tokenNames; }
+
+	@Override
+	public String[] getRuleNames() { return ruleNames; }
+
+	@Override
+	public String getSerializedATN() { return _serializedATN; }
+
+	@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 140: return JavaLetter_sempred((RuleContext)_localctx, predIndex);
+		case 141: return JavaLetterOrDigit_sempred((RuleContext)_localctx, predIndex);
+		}
+		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;
+	}
+	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;
+	}
+
+	public static final String _serializedATN =
+		"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\2k\u042e\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\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\u0281\n\64"+
+		"\3\65\3\65\5\65\u0285\n\65\3\66\3\66\5\66\u0289\n\66\3\67\3\67\5\67\u028d"+
+		"\n\67\38\38\58\u0291\n8\39\39\3:\3:\3:\5:\u0298\n:\3:\3:\3:\5:\u029d\n"+
+		":\5:\u029f\n:\3;\3;\7;\u02a3\n;\f;\16;\u02a6\13;\3;\5;\u02a9\n;\3<\3<"+
+		"\5<\u02ad\n<\3=\3=\3>\3>\5>\u02b3\n>\3?\6?\u02b6\n?\r?\16?\u02b7\3@\3"+
+		"@\3@\3@\3A\3A\7A\u02c0\nA\fA\16A\u02c3\13A\3A\5A\u02c6\nA\3B\3B\3C\3C"+
+		"\5C\u02cc\nC\3D\3D\5D\u02d0\nD\3D\3D\3E\3E\7E\u02d6\nE\fE\16E\u02d9\13"+
+		"E\3E\5E\u02dc\nE\3F\3F\3G\3G\5G\u02e2\nG\3H\3H\3H\3H\3I\3I\7I\u02ea\n"+
+		"I\fI\16I\u02ed\13I\3I\5I\u02f0\nI\3J\3J\3K\3K\5K\u02f6\nK\3L\3L\5L\u02fa"+
+		"\nL\3M\3M\3M\5M\u02ff\nM\3M\5M\u0302\nM\3M\5M\u0305\nM\3M\3M\3M\5M\u030a"+
+		"\nM\3M\5M\u030d\nM\3M\3M\3M\5M\u0312\nM\3M\3M\3M\5M\u0317\nM\3N\3N\3N"+
+		"\3O\3O\3P\5P\u031f\nP\3P\3P\3Q\3Q\3R\3R\3S\3S\3S\5S\u032a\nS\3T\3T\5T"+
+		"\u032e\nT\3T\3T\3T\5T\u0333\nT\3T\3T\5T\u0337\nT\3U\3U\3U\3V\3V\3W\3W"+
+		"\3W\3W\3W\3W\3W\3W\3W\5W\u0347\nW\3X\3X\3X\3X\3X\3X\3X\3X\5X\u0351\nX"+
+		"\3Y\3Y\3Z\3Z\5Z\u0357\nZ\3Z\3Z\3[\6[\u035c\n[\r[\16[\u035d\3\\\3\\\5\\"+
+		"\u0362\n\\\3]\3]\3]\3]\5]\u0368\n]\3^\3^\3^\3^\3^\3^\3^\3^\3^\3^\3^\5"+
+		"^\u0375\n^\3_\3_\3_\3_\3_\3_\3_\3`\3`\3a\3a\3a\3a\3a\3b\3b\3c\3c\3d\3"+
+		"d\3e\3e\3f\3f\3g\3g\3h\3h\3i\3i\3j\3j\3k\3k\3l\3l\3m\3m\3n\3n\3o\3o\3"+
+		"p\3p\3q\3q\3r\3r\3r\3s\3s\3s\3t\3t\3t\3u\3u\3u\3v\3v\3v\3w\3w\3w\3x\3"+
+		"x\3x\3y\3y\3y\3z\3z\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\u0082\3\u0083\3\u0083\3\u0083\3\u0084"+
+		"\3\u0084\3\u0084\3\u0085\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\u008a\3\u008b\3\u008b\3\u008b\3\u008b\3\u008c\3\u008c"+
+		"\3\u008c\3\u008c\3\u008c\3\u008d\3\u008d\7\u008d\u03f4\n\u008d\f\u008d"+
+		"\16\u008d\u03f7\13\u008d\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e"+
+		"\5\u008e\u03ff\n\u008e\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f"+
+		"\5\u008f\u0407\n\u008f\3\u0090\3\u0090\3\u0091\3\u0091\3\u0091\3\u0091"+
+		"\3\u0092\6\u0092\u0410\n\u0092\r\u0092\16\u0092\u0411\3\u0092\3\u0092"+
+		"\3\u0093\3\u0093\3\u0093\3\u0093\7\u0093\u041a\n\u0093\f\u0093\16\u0093"+
+		"\u041d\13\u0093\3\u0093\3\u0093\3\u0093\3\u0093\3\u0093\3\u0094\3\u0094"+
+		"\3\u0094\3\u0094\7\u0094\u0428\n\u0094\f\u0094\16\u0094\u042b\13\u0094"+
+		"\3\u0094\3\u0094\3\u041b\2\u0095\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\2y\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\66\u0099\2\u009b\2\u009d\2\u009f\2\u00a1\2\u00a3\2\u00a5\2\u00a7"+
+		"\2\u00a9\2\u00ab\2\u00ad\67\u00af8\u00b1\2\u00b39\u00b5\2\u00b7\2\u00b9"+
+		"\2\u00bb\2\u00bd\2\u00bf\2\u00c1:\u00c3;\u00c5<\u00c7=\u00c9>\u00cb?\u00cd"+
+		"@\u00cfA\u00d1B\u00d3C\u00d5D\u00d7E\u00d9F\u00dbG\u00ddH\u00dfI\u00e1"+
+		"J\u00e3K\u00e5L\u00e7M\u00e9N\u00ebO\u00edP\u00efQ\u00f1R\u00f3S\u00f5"+
+		"T\u00f7U\u00f9V\u00fbW\u00fdX\u00ffY\u0101Z\u0103[\u0105\\\u0107]\u0109"+
+		"^\u010b_\u010d`\u010fa\u0111b\u0113c\u0115d\u0117e\u0119f\u011b\2\u011d"+
+		"\2\u011fg\u0121h\u0123i\u0125j\u0127k\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\2FFHHffhh\4\2R"+
+		"Rrr\4\2))^^\4\2$$^^\n\2$$))^^ddhhppttvv\3\2\62\65\6\2&&C\\aac|\4\2\2\u0101"+
+		"\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\u043c\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\2"+
+		"C\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"+
+		"\u0097\3\2\2\2\2\u00ad\3\2\2\2\2\u00af\3\2\2\2\2\u00b3\3\2\2\2\2\u00c1"+
+		"\3\2\2\2\2\u00c3\3\2\2\2\2\u00c5\3\2\2\2\2\u00c7\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\u011f"+
+		"\3\2\2\2\2\u0121\3\2\2\2\2\u0123\3\2\2\2\2\u0125\3\2\2\2\2\u0127\3\2\2"+
+		"\2\3\u0129\3\2\2\2\5\u0132\3\2\2\2\7\u0139\3\2\2\2\t\u0141\3\2\2\2\13"+
+		"\u0147\3\2\2\2\r\u014c\3\2\2\2\17\u0151\3\2\2\2\21\u0157\3\2\2\2\23\u015c"+
+		"\3\2\2\2\25\u0162\3\2\2\2\27\u0168\3\2\2\2\31\u0171\3\2\2\2\33\u0179\3"+
+		"\2\2\2\35\u017c\3\2\2\2\37\u0183\3\2\2\2!\u0188\3\2\2\2#\u018d\3\2\2\2"+
+		"%\u0195\3\2\2\2\'\u019b\3\2\2\2)\u01a3\3\2\2\2+\u01a9\3\2\2\2-\u01ad\3"+
+		"\2\2\2/\u01b0\3\2\2\2\61\u01b5\3\2\2\2\63\u01c0\3\2\2\2\65\u01c7\3\2\2"+
+		"\2\67\u01d2\3\2\2\29\u01d6\3\2\2\2;\u01e0\3\2\2\2=\u01e5\3\2\2\2?\u01ec"+
+		"\3\2\2\2A\u01f0\3\2\2\2C\u01f8\3\2\2\2E\u0200\3\2\2\2G\u020a\3\2\2\2I"+
+		"\u0211\3\2\2\2K\u0218\3\2\2\2M\u021e\3\2\2\2O\u0225\3\2\2\2Q\u022e\3\2"+
+		"\2\2S\u0234\3\2\2\2U\u023b\3\2\2\2W\u0248\3\2\2\2Y\u024d\3\2\2\2[\u0253"+
+		"\3\2\2\2]\u025a\3\2\2\2_\u0264\3\2\2\2a\u0268\3\2\2\2c\u026d\3\2\2\2e"+
+		"\u0276\3\2\2\2g\u0280\3\2\2\2i\u0282\3\2\2\2k\u0286\3\2\2\2m\u028a\3\2"+
+		"\2\2o\u028e\3\2\2\2q\u0292\3\2\2\2s\u029e\3\2\2\2u\u02a0\3\2\2\2w\u02ac"+
+		"\3\2\2\2y\u02ae\3\2\2\2{\u02b2\3\2\2\2}\u02b5\3\2\2\2\177\u02b9\3\2\2"+
+		"\2\u0081\u02bd\3\2\2\2\u0083\u02c7\3\2\2\2\u0085\u02cb\3\2\2\2\u0087\u02cd"+
+		"\3\2\2\2\u0089\u02d3\3\2\2\2\u008b\u02dd\3\2\2\2\u008d\u02e1\3\2\2\2\u008f"+
+		"\u02e3\3\2\2\2\u0091\u02e7\3\2\2\2\u0093\u02f1\3\2\2\2\u0095\u02f5\3\2"+
+		"\2\2\u0097\u02f9\3\2\2\2\u0099\u0316\3\2\2\2\u009b\u0318\3\2\2\2\u009d"+
+		"\u031b\3\2\2\2\u009f\u031e\3\2\2\2\u00a1\u0322\3\2\2\2\u00a3\u0324\3\2"+
+		"\2\2\u00a5\u0326\3\2\2\2\u00a7\u0336\3\2\2\2\u00a9\u0338\3\2\2\2\u00ab"+
+		"\u033b\3\2\2\2\u00ad\u0346\3\2\2\2\u00af\u0350\3\2\2\2\u00b1\u0352\3\2"+
+		"\2\2\u00b3\u0354\3\2\2\2\u00b5\u035b\3\2\2\2\u00b7\u0361\3\2\2\2\u00b9"+
+		"\u0367\3\2\2\2\u00bb\u0374\3\2\2\2\u00bd\u0376\3\2\2\2\u00bf\u037d\3\2"+
+		"\2\2\u00c1\u037f\3\2\2\2\u00c3\u0384\3\2\2\2\u00c5\u0386\3\2\2\2\u00c7"+
+		"\u0388\3\2\2\2\u00c9\u038a\3\2\2\2\u00cb\u038c\3\2\2\2\u00cd\u038e\3\2"+
+		"\2\2\u00cf\u0390\3\2\2\2\u00d1\u0392\3\2\2\2\u00d3\u0394\3\2\2\2\u00d5"+
+		"\u0396\3\2\2\2\u00d7\u0398\3\2\2\2\u00d9\u039a\3\2\2\2\u00db\u039c\3\2"+
+		"\2\2\u00dd\u039e\3\2\2\2\u00df\u03a0\3\2\2\2\u00e1\u03a2\3\2\2\2\u00e3"+
+		"\u03a4\3\2\2\2\u00e5\u03a7\3\2\2\2\u00e7\u03aa\3\2\2\2\u00e9\u03ad\3\2"+
+		"\2\2\u00eb\u03b0\3\2\2\2\u00ed\u03b3\3\2\2\2\u00ef\u03b6\3\2\2\2\u00f1"+
+		"\u03b9\3\2\2\2\u00f3\u03bc\3\2\2\2\u00f5\u03be\3\2\2\2\u00f7\u03c0\3\2"+
+		"\2\2\u00f9\u03c2\3\2\2\2\u00fb\u03c4\3\2\2\2\u00fd\u03c6\3\2\2\2\u00ff"+
+		"\u03c8\3\2\2\2\u0101\u03ca\3\2\2\2\u0103\u03cc\3\2\2\2\u0105\u03cf\3\2"+
+		"\2\2\u0107\u03d2\3\2\2\2\u0109\u03d5\3\2\2\2\u010b\u03d8\3\2\2\2\u010d"+
+		"\u03db\3\2\2\2\u010f\u03de\3\2\2\2\u0111\u03e1\3\2\2\2\u0113\u03e4\3\2"+
+		"\2\2\u0115\u03e8\3\2\2\2\u0117\u03ec\3\2\2\2\u0119\u03f1\3\2\2\2\u011b"+
+		"\u03fe\3\2\2\2\u011d\u0406\3\2\2\2\u011f\u0408\3\2\2\2\u0121\u040a\3\2"+
+		"\2\2\u0123\u040f\3\2\2\2\u0125\u0415\3\2\2\2\u0127\u0423\3\2\2\2\u0129"+
+		"\u012a\7c\2\2\u012a\u012b\7d\2\2\u012b\u012c\7u\2\2\u012c\u012d\7v\2\2"+
+		"\u012d\u012e\7t\2\2\u012e\u012f\7c\2\2\u012f\u0130\7e\2\2\u0130\u0131"+
+		"\7v\2\2\u0131\4\3\2\2\2\u0132\u0133\7c\2\2\u0133\u0134\7u\2\2\u0134\u0135"+
+		"\7u\2\2\u0135\u0136\7g\2\2\u0136\u0137\7t\2\2\u0137\u0138\7v\2\2\u0138"+
+		"\6\3\2\2\2\u0139\u013a\7d\2\2\u013a\u013b\7q\2\2\u013b\u013c\7q\2\2\u013c"+
+		"\u013d\7n\2\2\u013d\u013e\7g\2\2\u013e\u013f\7c\2\2\u013f\u0140\7p\2\2"+
+		"\u0140\b\3\2\2\2\u0141\u0142\7d\2\2\u0142\u0143\7t\2\2\u0143\u0144\7g"+
+		"\2\2\u0144\u0145\7c\2\2\u0145\u0146\7m\2\2\u0146\n\3\2\2\2\u0147\u0148"+
+		"\7d\2\2\u0148\u0149\7{\2\2\u0149\u014a\7v\2\2\u014a\u014b\7g\2\2\u014b"+
+		"\f\3\2\2\2\u014c\u014d\7e\2\2\u014d\u014e\7c\2\2\u014e\u014f\7u\2\2\u014f"+
+		"\u0150\7g\2\2\u0150\16\3\2\2\2\u0151\u0152\7e\2\2\u0152\u0153\7c\2\2\u0153"+
+		"\u0154\7v\2\2\u0154\u0155\7e\2\2\u0155\u0156\7j\2\2\u0156\20\3\2\2\2\u0157"+
+		"\u0158\7e\2\2\u0158\u0159\7j\2\2\u0159\u015a\7c\2\2\u015a\u015b\7t\2\2"+
+		"\u015b\22\3\2\2\2\u015c\u015d\7e\2\2\u015d\u015e\7n\2\2\u015e\u015f\7"+
+		"c\2\2\u015f\u0160\7u\2\2\u0160\u0161\7u\2\2\u0161\24\3\2\2\2\u0162\u0163"+
+		"\7e\2\2\u0163\u0164\7q\2\2\u0164\u0165\7p\2\2\u0165\u0166\7u\2\2\u0166"+
+		"\u0167\7v\2\2\u0167\26\3\2\2\2\u0168\u0169\7e\2\2\u0169\u016a\7q\2\2\u016a"+
+		"\u016b\7p\2\2\u016b\u016c\7v\2\2\u016c\u016d\7k\2\2\u016d\u016e\7p\2\2"+
+		"\u016e\u016f\7w\2\2\u016f\u0170\7g\2\2\u0170\30\3\2\2\2\u0171\u0172\7"+
+		"f\2\2\u0172\u0173\7g\2\2\u0173\u0174\7h\2\2\u0174\u0175\7c\2\2\u0175\u0176"+
+		"\7w\2\2\u0176\u0177\7n\2\2\u0177\u0178\7v\2\2\u0178\32\3\2\2\2\u0179\u017a"+
+		"\7f\2\2\u017a\u017b\7q\2\2\u017b\34\3\2\2\2\u017c\u017d\7f\2\2\u017d\u017e"+
+		"\7q\2\2\u017e\u017f\7w\2\2\u017f\u0180\7d\2\2\u0180\u0181\7n\2\2\u0181"+
+		"\u0182\7g\2\2\u0182\36\3\2\2\2\u0183\u0184\7g\2\2\u0184\u0185\7n\2\2\u0185"+
+		"\u0186\7u\2\2\u0186\u0187\7g\2\2\u0187 \3\2\2\2\u0188\u0189\7g\2\2\u0189"+
+		"\u018a\7p\2\2\u018a\u018b\7w\2\2\u018b\u018c\7o\2\2\u018c\"\3\2\2\2\u018d"+
+		"\u018e\7g\2\2\u018e\u018f\7z\2\2\u018f\u0190\7v\2\2\u0190\u0191\7g\2\2"+
+		"\u0191\u0192\7p\2\2\u0192\u0193\7f\2\2\u0193\u0194\7u\2\2\u0194$\3\2\2"+
+		"\2\u0195\u0196\7h\2\2\u0196\u0197\7k\2\2\u0197\u0198\7p\2\2\u0198\u0199"+
+		"\7c\2\2\u0199\u019a\7n\2\2\u019a&\3\2\2\2\u019b\u019c\7h\2\2\u019c\u019d"+
+		"\7k\2\2\u019d\u019e\7p\2\2\u019e\u019f\7c\2\2\u019f\u01a0\7n\2\2\u01a0"+
+		"\u01a1\7n\2\2\u01a1\u01a2\7{\2\2\u01a2(\3\2\2\2\u01a3\u01a4\7h\2\2\u01a4"+
+		"\u01a5\7n\2\2\u01a5\u01a6\7q\2\2\u01a6\u01a7\7c\2\2\u01a7\u01a8\7v\2\2"+
+		"\u01a8*\3\2\2\2\u01a9\u01aa\7h\2\2\u01aa\u01ab\7q\2\2\u01ab\u01ac\7t\2"+
+		"\2\u01ac,\3\2\2\2\u01ad\u01ae\7k\2\2\u01ae\u01af\7h\2\2\u01af.\3\2\2\2"+
+		"\u01b0\u01b1\7i\2\2\u01b1\u01b2\7q\2\2\u01b2\u01b3\7v\2\2\u01b3\u01b4"+
+		"\7q\2\2\u01b4\60\3\2\2\2\u01b5\u01b6\7k\2\2\u01b6\u01b7\7o\2\2\u01b7\u01b8"+
+		"\7r\2\2\u01b8\u01b9\7n\2\2\u01b9\u01ba\7g\2\2\u01ba\u01bb\7o\2\2\u01bb"+
+		"\u01bc\7g\2\2\u01bc\u01bd\7p\2\2\u01bd\u01be\7v\2\2\u01be\u01bf\7u\2\2"+
+		"\u01bf\62\3\2\2\2\u01c0\u01c1\7k\2\2\u01c1\u01c2\7o\2\2\u01c2\u01c3\7"+
+		"r\2\2\u01c3\u01c4\7q\2\2\u01c4\u01c5\7t\2\2\u01c5\u01c6\7v\2\2\u01c6\64"+
+		"\3\2\2\2\u01c7\u01c8\7k\2\2\u01c8\u01c9\7p\2\2\u01c9\u01ca\7u\2\2\u01ca"+
+		"\u01cb\7v\2\2\u01cb\u01cc\7c\2\2\u01cc\u01cd\7p\2\2\u01cd\u01ce\7e\2\2"+
+		"\u01ce\u01cf\7g\2\2\u01cf\u01d0\7q\2\2\u01d0\u01d1\7h\2\2\u01d1\66\3\2"+
+		"\2\2\u01d2\u01d3\7k\2\2\u01d3\u01d4\7p\2\2\u01d4\u01d5\7v\2\2\u01d58\3"+
+		"\2\2\2\u01d6\u01d7\7k\2\2\u01d7\u01d8\7p\2\2\u01d8\u01d9\7v\2\2\u01d9"+
+		"\u01da\7g\2\2\u01da\u01db\7t\2\2\u01db\u01dc\7h\2\2\u01dc\u01dd\7c\2\2"+
+		"\u01dd\u01de\7e\2\2\u01de\u01df\7g\2\2\u01df:\3\2\2\2\u01e0\u01e1\7n\2"+
+		"\2\u01e1\u01e2\7q\2\2\u01e2\u01e3\7p\2\2\u01e3\u01e4\7i\2\2\u01e4<\3\2"+
+		"\2\2\u01e5\u01e6\7p\2\2\u01e6\u01e7\7c\2\2\u01e7\u01e8\7v\2\2\u01e8\u01e9"+
+		"\7k\2\2\u01e9\u01ea\7x\2\2\u01ea\u01eb\7g\2\2\u01eb>\3\2\2\2\u01ec\u01ed"+
+		"\7p\2\2\u01ed\u01ee\7g\2\2\u01ee\u01ef\7y\2\2\u01ef@\3\2\2\2\u01f0\u01f1"+
+		"\7r\2\2\u01f1\u01f2\7c\2\2\u01f2\u01f3\7e\2\2\u01f3\u01f4\7m\2\2\u01f4"+
+		"\u01f5\7c\2\2\u01f5\u01f6\7i\2\2\u01f6\u01f7\7g\2\2\u01f7B\3\2\2\2\u01f8"+
+		"\u01f9\7r\2\2\u01f9\u01fa\7t\2\2\u01fa\u01fb\7k\2\2\u01fb\u01fc\7x\2\2"+
+		"\u01fc\u01fd\7c\2\2\u01fd\u01fe\7v\2\2\u01fe\u01ff\7g\2\2\u01ffD\3\2\2"+
+		"\2\u0200\u0201\7r\2\2\u0201\u0202\7t\2\2\u0202\u0203\7q\2\2\u0203\u0204"+
+		"\7v\2\2\u0204\u0205\7g\2\2\u0205\u0206\7e\2\2\u0206\u0207\7v\2\2\u0207"+
+		"\u0208\7g\2\2\u0208\u0209\7f\2\2\u0209F\3\2\2\2\u020a\u020b\7r\2\2\u020b"+
+		"\u020c\7w\2\2\u020c\u020d\7d\2\2\u020d\u020e\7n\2\2\u020e\u020f\7k\2\2"+
+		"\u020f\u0210\7e\2\2\u0210H\3\2\2\2\u0211\u0212\7t\2\2\u0212\u0213\7g\2"+
+		"\2\u0213\u0214\7v\2\2\u0214\u0215\7w\2\2\u0215\u0216\7t\2\2\u0216\u0217"+
+		"\7p\2\2\u0217J\3\2\2\2\u0218\u0219\7u\2\2\u0219\u021a\7j\2\2\u021a\u021b"+
+		"\7q\2\2\u021b\u021c\7t\2\2\u021c\u021d\7v\2\2\u021dL\3\2\2\2\u021e\u021f"+
+		"\7u\2\2\u021f\u0220\7v\2\2\u0220\u0221\7c\2\2\u0221\u0222\7v\2\2\u0222"+
+		"\u0223\7k\2\2\u0223\u0224\7e\2\2\u0224N\3\2\2\2\u0225\u0226\7u\2\2\u0226"+
+		"\u0227\7v\2\2\u0227\u0228\7t\2\2\u0228\u0229\7k\2\2\u0229\u022a\7e\2\2"+
+		"\u022a\u022b\7v\2\2\u022b\u022c\7h\2\2\u022c\u022d\7r\2\2\u022dP\3\2\2"+
+		"\2\u022e\u022f\7u\2\2\u022f\u0230\7w\2\2\u0230\u0231\7r\2\2\u0231\u0232"+
+		"\7g\2\2\u0232\u0233\7t\2\2\u0233R\3\2\2\2\u0234\u0235\7u\2\2\u0235\u0236"+
+		"\7y\2\2\u0236\u0237\7k\2\2\u0237\u0238\7v\2\2\u0238\u0239\7e\2\2\u0239"+
+		"\u023a\7j\2\2\u023aT\3\2\2\2\u023b\u023c\7u\2\2\u023c\u023d\7{\2\2\u023d"+
+		"\u023e\7p\2\2\u023e\u023f\7e\2\2\u023f\u0240\7j\2\2\u0240\u0241\7t\2\2"+
+		"\u0241\u0242\7q\2\2\u0242\u0243\7p\2\2\u0243\u0244\7k\2\2\u0244\u0245"+
+		"\7|\2\2\u0245\u0246\7g\2\2\u0246\u0247\7f\2\2\u0247V\3\2\2\2\u0248\u0249"+
+		"\7v\2\2\u0249\u024a\7j\2\2\u024a\u024b\7k\2\2\u024b\u024c\7u\2\2\u024c"+
+		"X\3\2\2\2\u024d\u024e\7v\2\2\u024e\u024f\7j\2\2\u024f\u0250\7t\2\2\u0250"+
+		"\u0251\7q\2\2\u0251\u0252\7y\2\2\u0252Z\3\2\2\2\u0253\u0254\7v\2\2\u0254"+
+		"\u0255\7j\2\2\u0255\u0256\7t\2\2\u0256\u0257\7q\2\2\u0257\u0258\7y\2\2"+
+		"\u0258\u0259\7u\2\2\u0259\\\3\2\2\2\u025a\u025b\7v\2\2\u025b\u025c\7t"+
+		"\2\2\u025c\u025d\7c\2\2\u025d\u025e\7p\2\2\u025e\u025f\7u\2\2\u025f\u0260"+
+		"\7k\2\2\u0260\u0261\7g\2\2\u0261\u0262\7p\2\2\u0262\u0263\7v\2\2\u0263"+
+		"^\3\2\2\2\u0264\u0265\7v\2\2\u0265\u0266\7t\2\2\u0266\u0267\7{\2\2\u0267"+
+		"`\3\2\2\2\u0268\u0269\7x\2\2\u0269\u026a\7q\2\2\u026a\u026b\7k\2\2\u026b"+
+		"\u026c\7f\2\2\u026cb\3\2\2\2\u026d\u026e\7x\2\2\u026e\u026f\7q\2\2\u026f"+
+		"\u0270\7n\2\2\u0270\u0271\7c\2\2\u0271\u0272\7v\2\2\u0272\u0273\7k\2\2"+
+		"\u0273\u0274\7n\2\2\u0274\u0275\7g\2\2\u0275d\3\2\2\2\u0276\u0277\7y\2"+
+		"\2\u0277\u0278\7j\2\2\u0278\u0279\7k\2\2\u0279\u027a\7n\2\2\u027a\u027b"+
+		"\7g\2\2\u027bf\3\2\2\2\u027c\u0281\5i\65\2\u027d\u0281\5k\66\2\u027e\u0281"+
+		"\5m\67\2\u027f\u0281\5o8\2\u0280\u027c\3\2\2\2\u0280\u027d\3\2\2\2\u0280"+
+		"\u027e\3\2\2\2\u0280\u027f\3\2\2\2\u0281h\3\2\2\2\u0282\u0284\5s:\2\u0283"+
+		"\u0285\5q9\2\u0284\u0283\3\2\2\2\u0284\u0285\3\2\2\2\u0285j\3\2\2\2\u0286"+
+		"\u0288\5\177@\2\u0287\u0289\5q9\2\u0288\u0287\3\2\2\2\u0288\u0289\3\2"+
+		"\2\2\u0289l\3\2\2\2\u028a\u028c\5\u0087D\2\u028b\u028d\5q9\2\u028c\u028b"+
+		"\3\2\2\2\u028c\u028d\3\2\2\2\u028dn\3\2\2\2\u028e\u0290\5\u008fH\2\u028f"+
+		"\u0291\5q9\2\u0290\u028f\3\2\2\2\u0290\u0291\3\2\2\2\u0291p\3\2\2\2\u0292"+
+		"\u0293\t\2\2\2\u0293r\3\2\2\2\u0294\u029f\7\62\2\2\u0295\u029c\5y=\2\u0296"+
+		"\u0298\5u;\2\u0297\u0296\3\2\2\2\u0297\u0298\3\2\2\2\u0298\u029d\3\2\2"+
+		"\2\u0299\u029a\5}?\2\u029a\u029b\5u;\2\u029b\u029d\3\2\2\2\u029c\u0297"+
+		"\3\2\2\2\u029c\u0299\3\2\2\2\u029d\u029f\3\2\2\2\u029e\u0294\3\2\2\2\u029e"+
+		"\u0295\3\2\2\2\u029ft\3\2\2\2\u02a0\u02a8\5w<\2\u02a1\u02a3\5{>\2\u02a2"+
+		"\u02a1\3\2\2\2\u02a3\u02a6\3\2\2\2\u02a4\u02a2\3\2\2\2\u02a4\u02a5\3\2"+
+		"\2\2\u02a5\u02a7\3\2\2\2\u02a6\u02a4\3\2\2\2\u02a7\u02a9\5w<\2\u02a8\u02a4"+
+		"\3\2\2\2\u02a8\u02a9\3\2\2\2\u02a9v\3\2\2\2\u02aa\u02ad\7\62\2\2\u02ab"+
+		"\u02ad\5y=\2\u02ac\u02aa\3\2\2\2\u02ac\u02ab\3\2\2\2\u02adx\3\2\2\2\u02ae"+
+		"\u02af\t\3\2\2\u02afz\3\2\2\2\u02b0\u02b3\5w<\2\u02b1\u02b3\7a\2\2\u02b2"+
+		"\u02b0\3\2\2\2\u02b2\u02b1\3\2\2\2\u02b3|\3\2\2\2\u02b4\u02b6\7a\2\2\u02b5"+
+		"\u02b4\3\2\2\2\u02b6\u02b7\3\2\2\2\u02b7\u02b5\3\2\2\2\u02b7\u02b8\3\2"+
+		"\2\2\u02b8~\3\2\2\2\u02b9\u02ba\7\62\2\2\u02ba\u02bb\t\4\2\2\u02bb\u02bc"+
+		"\5\u0081A\2\u02bc\u0080\3\2\2\2\u02bd\u02c5\5\u0083B\2\u02be\u02c0\5\u0085"+
+		"C\2\u02bf\u02be\3\2\2\2\u02c0\u02c3\3\2\2\2\u02c1\u02bf\3\2\2\2\u02c1"+
+		"\u02c2\3\2\2\2\u02c2\u02c4\3\2\2\2\u02c3\u02c1\3\2\2\2\u02c4\u02c6\5\u0083"+
+		"B\2\u02c5\u02c1\3\2\2\2\u02c5\u02c6\3\2\2\2\u02c6\u0082\3\2\2\2\u02c7"+
+		"\u02c8\t\5\2\2\u02c8\u0084\3\2\2\2\u02c9\u02cc\5\u0083B\2\u02ca\u02cc"+
+		"\7a\2\2\u02cb\u02c9\3\2\2\2\u02cb\u02ca\3\2\2\2\u02cc\u0086\3\2\2\2\u02cd"+
+		"\u02cf\7\62\2\2\u02ce\u02d0\5}?\2\u02cf\u02ce\3\2\2\2\u02cf\u02d0\3\2"+
+		"\2\2\u02d0\u02d1\3\2\2\2\u02d1\u02d2\5\u0089E\2\u02d2\u0088\3\2\2\2\u02d3"+
+		"\u02db\5\u008bF\2\u02d4\u02d6\5\u008dG\2\u02d5\u02d4\3\2\2\2\u02d6\u02d9"+
+		"\3\2\2\2\u02d7\u02d5\3\2\2\2\u02d7\u02d8\3\2\2\2\u02d8\u02da\3\2\2\2\u02d9"+
+		"\u02d7\3\2\2\2\u02da\u02dc\5\u008bF\2\u02db\u02d7\3\2\2\2\u02db\u02dc"+
+		"\3\2\2\2\u02dc\u008a\3\2\2\2\u02dd\u02de\t\6\2\2\u02de\u008c\3\2\2\2\u02df"+
+		"\u02e2\5\u008bF\2\u02e0\u02e2\7a\2\2\u02e1\u02df\3\2\2\2\u02e1\u02e0\3"+
+		"\2\2\2\u02e2\u008e\3\2\2\2\u02e3\u02e4\7\62\2\2\u02e4\u02e5\t\7\2\2\u02e5"+
+		"\u02e6\5\u0091I\2\u02e6\u0090\3\2\2\2\u02e7\u02ef\5\u0093J\2\u02e8\u02ea"+
+		"\5\u0095K\2\u02e9\u02e8\3\2\2\2\u02ea\u02ed\3\2\2\2\u02eb\u02e9\3\2\2"+
+		"\2\u02eb\u02ec\3\2\2\2\u02ec\u02ee\3\2\2\2\u02ed\u02eb\3\2\2\2\u02ee\u02f0"+
+		"\5\u0093J\2\u02ef\u02eb\3\2\2\2\u02ef\u02f0\3\2\2\2\u02f0\u0092\3\2\2"+
+		"\2\u02f1\u02f2\t\b\2\2\u02f2\u0094\3\2\2\2\u02f3\u02f6\5\u0093J\2\u02f4"+
+		"\u02f6\7a\2\2\u02f5\u02f3\3\2\2\2\u02f5\u02f4\3\2\2\2\u02f6\u0096\3\2"+
+		"\2\2\u02f7\u02fa\5\u0099M\2\u02f8\u02fa\5\u00a5S\2\u02f9\u02f7\3\2\2\2"+
+		"\u02f9\u02f8\3\2\2\2\u02fa\u0098\3\2\2\2\u02fb\u02fc\5u;\2\u02fc\u02fe"+
+		"\7\60\2\2\u02fd\u02ff\5u;\2\u02fe\u02fd\3\2\2\2\u02fe\u02ff\3\2\2\2\u02ff"+
+		"\u0301\3\2\2\2\u0300\u0302\5\u009bN\2\u0301\u0300\3\2\2\2\u0301\u0302"+
+		"\3\2\2\2\u0302\u0304\3\2\2\2\u0303\u0305\5\u00a3R\2\u0304\u0303\3\2\2"+
+		"\2\u0304\u0305\3\2\2\2\u0305\u0317\3\2\2\2\u0306\u0307\7\60\2\2\u0307"+
+		"\u0309\5u;\2\u0308\u030a\5\u009bN\2\u0309\u0308\3\2\2\2\u0309\u030a\3"+
+		"\2\2\2\u030a\u030c\3\2\2\2\u030b\u030d\5\u00a3R\2\u030c\u030b\3\2\2\2"+
+		"\u030c\u030d\3\2\2\2\u030d\u0317\3\2\2\2\u030e\u030f\5u;\2\u030f\u0311"+
+		"\5\u009bN\2\u0310\u0312\5\u00a3R\2\u0311\u0310\3\2\2\2\u0311\u0312\3\2"+
+		"\2\2\u0312\u0317\3\2\2\2\u0313\u0314\5u;\2\u0314\u0315\5\u00a3R\2\u0315"+
+		"\u0317\3\2\2\2\u0316\u02fb\3\2\2\2\u0316\u0306\3\2\2\2\u0316\u030e\3\2"+
+		"\2\2\u0316\u0313\3\2\2\2\u0317\u009a\3\2\2\2\u0318\u0319\5\u009dO\2\u0319"+
+		"\u031a\5\u009fP\2\u031a\u009c\3\2\2\2\u031b\u031c\t\t\2\2\u031c\u009e"+
+		"\3\2\2\2\u031d\u031f\5\u00a1Q\2\u031e\u031d\3\2\2\2\u031e\u031f\3\2\2"+
+		"\2\u031f\u0320\3\2\2\2\u0320\u0321\5u;\2\u0321\u00a0\3\2\2\2\u0322\u0323"+
+		"\t\n\2\2\u0323\u00a2\3\2\2\2\u0324\u0325\t\13\2\2\u0325\u00a4\3\2\2\2"+
+		"\u0326\u0327\5\u00a7T\2\u0327\u0329\5\u00a9U\2\u0328\u032a\5\u00a3R\2"+
+		"\u0329\u0328\3\2\2\2\u0329\u032a\3\2\2\2\u032a\u00a6\3\2\2\2\u032b\u032d"+
+		"\5\177@\2\u032c\u032e\7\60\2\2\u032d\u032c\3\2\2\2\u032d\u032e\3\2\2\2"+
+		"\u032e\u0337\3\2\2\2\u032f\u0330\7\62\2\2\u0330\u0332\t\4\2\2\u0331\u0333"+
+		"\5\u0081A\2\u0332\u0331\3\2\2\2\u0332\u0333\3\2\2\2\u0333\u0334\3\2\2"+
+		"\2\u0334\u0335\7\60\2\2\u0335\u0337\5\u0081A\2\u0336\u032b\3\2\2\2\u0336"+
+		"\u032f\3\2\2\2\u0337\u00a8\3\2\2\2\u0338\u0339\5\u00abV\2\u0339\u033a"+
+		"\5\u009fP\2\u033a\u00aa\3\2\2\2\u033b\u033c\t\f\2\2\u033c\u00ac\3\2\2"+
+		"\2\u033d\u033e\7v\2\2\u033e\u033f\7t\2\2\u033f\u0340\7w\2\2\u0340\u0347"+
+		"\7g\2\2\u0341\u0342\7h\2\2\u0342\u0343\7c\2\2\u0343\u0344\7n\2\2\u0344"+
+		"\u0345\7u\2\2\u0345\u0347\7g\2\2\u0346\u033d\3\2\2\2\u0346\u0341\3\2\2"+
+		"\2\u0347\u00ae\3\2\2\2\u0348\u0349\7)\2\2\u0349\u034a\5\u00b1Y\2\u034a"+
+		"\u034b\7)\2\2\u034b\u0351\3\2\2\2\u034c\u034d\7)\2\2\u034d\u034e\5\u00b9"+
+		"]\2\u034e\u034f\7)\2\2\u034f\u0351\3\2\2\2\u0350\u0348\3\2\2\2\u0350\u034c"+
+		"\3\2\2\2\u0351\u00b0\3\2\2\2\u0352\u0353\n\r\2\2\u0353\u00b2\3\2\2\2\u0354"+
+		"\u0356\7$\2\2\u0355\u0357\5\u00b5[\2\u0356\u0355\3\2\2\2\u0356\u0357\3"+
+		"\2\2\2\u0357\u0358\3\2\2\2\u0358\u0359\7$\2\2\u0359\u00b4\3\2\2\2\u035a"+
+		"\u035c\5\u00b7\\\2\u035b\u035a\3\2\2\2\u035c\u035d\3\2\2\2\u035d\u035b"+
+		"\3\2\2\2\u035d\u035e\3\2\2\2\u035e\u00b6\3\2\2\2\u035f\u0362\n\16\2\2"+
+		"\u0360\u0362\5\u00b9]\2\u0361\u035f\3\2\2\2\u0361\u0360\3\2\2\2\u0362"+
+		"\u00b8\3\2\2\2\u0363\u0364\7^\2\2\u0364\u0368\t\17\2\2\u0365\u0368\5\u00bb"+
+		"^\2\u0366\u0368\5\u00bd_\2\u0367\u0363\3\2\2\2\u0367\u0365\3\2\2\2\u0367"+
+		"\u0366\3\2\2\2\u0368\u00ba\3\2\2\2\u0369\u036a\7^\2\2\u036a\u0375\5\u008b"+
+		"F\2\u036b\u036c\7^\2\2\u036c\u036d\5\u008bF\2\u036d\u036e\5\u008bF\2\u036e"+
+		"\u0375\3\2\2\2\u036f\u0370\7^\2\2\u0370\u0371\5\u00bf`\2\u0371\u0372\5"+
+		"\u008bF\2\u0372\u0373\5\u008bF\2\u0373\u0375\3\2\2\2\u0374\u0369\3\2\2"+
+		"\2\u0374\u036b\3\2\2\2\u0374\u036f\3\2\2\2\u0375\u00bc\3\2\2\2\u0376\u0377"+
+		"\7^\2\2\u0377\u0378\7w\2\2\u0378\u0379\5\u0083B\2\u0379\u037a\5\u0083"+
+		"B\2\u037a\u037b\5\u0083B\2\u037b\u037c\5\u0083B\2\u037c\u00be\3\2\2\2"+
+		"\u037d\u037e\t\20\2\2\u037e\u00c0\3\2\2\2\u037f\u0380\7p\2\2\u0380\u0381"+
+		"\7w\2\2\u0381\u0382\7n\2\2\u0382\u0383\7n\2\2\u0383\u00c2\3\2\2\2\u0384"+
+		"\u0385\7*\2\2\u0385\u00c4\3\2\2\2\u0386\u0387\7+\2\2\u0387\u00c6\3\2\2"+
+		"\2\u0388\u0389\7}\2\2\u0389\u00c8\3\2\2\2\u038a\u038b\7\177\2\2\u038b"+
+		"\u00ca\3\2\2\2\u038c\u038d\7]\2\2\u038d\u00cc\3\2\2\2\u038e\u038f\7_\2"+
+		"\2\u038f\u00ce\3\2\2\2\u0390\u0391\7=\2\2\u0391\u00d0\3\2\2\2\u0392\u0393"+
+		"\7.\2\2\u0393\u00d2\3\2\2\2\u0394\u0395\7\60\2\2\u0395\u00d4\3\2\2\2\u0396"+
+		"\u0397\7?\2\2\u0397\u00d6\3\2\2\2\u0398\u0399\7@\2\2\u0399\u00d8\3\2\2"+
+		"\2\u039a\u039b\7>\2\2\u039b\u00da\3\2\2\2\u039c\u039d\7#\2\2\u039d\u00dc"+
+		"\3\2\2\2\u039e\u039f\7\u0080\2\2\u039f\u00de\3\2\2\2\u03a0\u03a1\7A\2"+
+		"\2\u03a1\u00e0\3\2\2\2\u03a2\u03a3\7<\2\2\u03a3\u00e2\3\2\2\2\u03a4\u03a5"+
+		"\7?\2\2\u03a5\u03a6\7?\2\2\u03a6\u00e4\3\2\2\2\u03a7\u03a8\7>\2\2\u03a8"+
+		"\u03a9\7?\2\2\u03a9\u00e6\3\2\2\2\u03aa\u03ab\7@\2\2\u03ab\u03ac\7?\2"+
+		"\2\u03ac\u00e8\3\2\2\2\u03ad\u03ae\7#\2\2\u03ae\u03af\7?\2\2\u03af\u00ea"+
+		"\3\2\2\2\u03b0\u03b1\7(\2\2\u03b1\u03b2\7(\2\2\u03b2\u00ec\3\2\2\2\u03b3"+
+		"\u03b4\7~\2\2\u03b4\u03b5\7~\2\2\u03b5\u00ee\3\2\2\2\u03b6\u03b7\7-\2"+
+		"\2\u03b7\u03b8\7-\2\2\u03b8\u00f0\3\2\2\2\u03b9\u03ba\7/\2\2\u03ba\u03bb"+
+		"\7/\2\2\u03bb\u00f2\3\2\2\2\u03bc\u03bd\7-\2\2\u03bd\u00f4\3\2\2\2\u03be"+
+		"\u03bf\7/\2\2\u03bf\u00f6\3\2\2\2\u03c0\u03c1\7,\2\2\u03c1\u00f8\3\2\2"+
+		"\2\u03c2\u03c3\7\61\2\2\u03c3\u00fa\3\2\2\2\u03c4\u03c5\7(\2\2\u03c5\u00fc"+
+		"\3\2\2\2\u03c6\u03c7\7~\2\2\u03c7\u00fe\3\2\2\2\u03c8\u03c9\7`\2\2\u03c9"+
+		"\u0100\3\2\2\2\u03ca\u03cb\7\'\2\2\u03cb\u0102\3\2\2\2\u03cc\u03cd\7-"+
+		"\2\2\u03cd\u03ce\7?\2\2\u03ce\u0104\3\2\2\2\u03cf\u03d0\7/\2\2\u03d0\u03d1"+
+		"\7?\2\2\u03d1\u0106\3\2\2\2\u03d2\u03d3\7,\2\2\u03d3\u03d4\7?\2\2\u03d4"+
+		"\u0108\3\2\2\2\u03d5\u03d6\7\61\2\2\u03d6\u03d7\7?\2\2\u03d7\u010a\3\2"+
+		"\2\2\u03d8\u03d9\7(\2\2\u03d9\u03da\7?\2\2\u03da\u010c\3\2\2\2\u03db\u03dc"+
+		"\7~\2\2\u03dc\u03dd\7?\2\2\u03dd\u010e\3\2\2\2\u03de\u03df\7`\2\2\u03df"+
+		"\u03e0\7?\2\2\u03e0\u0110\3\2\2\2\u03e1\u03e2\7\'\2\2\u03e2\u03e3\7?\2"+
+		"\2\u03e3\u0112\3\2\2\2\u03e4\u03e5\7>\2\2\u03e5\u03e6\7>\2\2\u03e6\u03e7"+
+		"\7?\2\2\u03e7\u0114\3\2\2\2\u03e8\u03e9\7@\2\2\u03e9\u03ea\7@\2\2\u03ea"+
+		"\u03eb\7?\2\2\u03eb\u0116\3\2\2\2\u03ec\u03ed\7@\2\2\u03ed\u03ee\7@\2"+
+		"\2\u03ee\u03ef\7@\2\2\u03ef\u03f0\7?\2\2\u03f0\u0118\3\2\2\2\u03f1\u03f5"+
+		"\5\u011b\u008e\2\u03f2\u03f4\5\u011d\u008f\2\u03f3\u03f2\3\2\2\2\u03f4"+
+		"\u03f7\3\2\2\2\u03f5\u03f3\3\2\2\2\u03f5\u03f6\3\2\2\2\u03f6\u011a\3\2"+
+		"\2\2\u03f7\u03f5\3\2\2\2\u03f8\u03ff\t\21\2\2\u03f9\u03fa\n\22\2\2\u03fa"+
+		"\u03ff\6\u008e\2\2\u03fb\u03fc\t\23\2\2\u03fc\u03fd\t\24\2\2\u03fd\u03ff"+
+		"\6\u008e\3\2\u03fe\u03f8\3\2\2\2\u03fe\u03f9\3\2\2\2\u03fe\u03fb\3\2\2"+
+		"\2\u03ff\u011c\3\2\2\2\u0400\u0407\t\25\2\2\u0401\u0402\n\22\2\2\u0402"+
+		"\u0407\6\u008f\4\2\u0403\u0404\t\23\2\2\u0404\u0405\t\24\2\2\u0405\u0407"+
+		"\6\u008f\5\2\u0406\u0400\3\2\2\2\u0406\u0401\3\2\2\2\u0406\u0403\3\2\2"+
+		"\2\u0407\u011e\3\2\2\2\u0408\u0409\7B\2\2\u0409\u0120\3\2\2\2\u040a\u040b"+
+		"\7\60\2\2\u040b\u040c\7\60\2\2\u040c\u040d\7\60\2\2\u040d\u0122\3\2\2"+
+		"\2\u040e\u0410\t\26\2\2\u040f\u040e\3\2\2\2\u0410\u0411\3\2\2\2\u0411"+
+		"\u040f\3\2\2\2\u0411\u0412\3\2\2\2\u0412\u0413\3\2\2\2\u0413\u0414\b\u0092"+
+		"\2\2\u0414\u0124\3\2\2\2\u0415\u0416\7\61\2\2\u0416\u0417\7,\2\2\u0417"+
+		"\u041b\3\2\2\2\u0418\u041a\13\2\2\2\u0419\u0418\3\2\2\2\u041a\u041d\3"+
+		"\2\2\2\u041b\u041c\3\2\2\2\u041b\u0419\3\2\2\2\u041c\u041e\3\2\2\2\u041d"+
+		"\u041b\3\2\2\2\u041e\u041f\7,\2\2\u041f\u0420\7\61\2\2\u0420\u0421\3\2"+
+		"\2\2\u0421\u0422\b\u0093\2\2\u0422\u0126\3\2\2\2\u0423\u0424\7\61\2\2"+
+		"\u0424\u0425\7\61\2\2\u0425\u0429\3\2\2\2\u0426\u0428\n\27\2\2\u0427\u0426"+
+		"\3\2\2\2\u0428\u042b\3\2\2\2\u0429\u0427\3\2\2\2\u0429\u042a\3\2\2\2\u042a"+
+		"\u042c\3\2\2\2\u042b\u0429\3\2\2\2\u042c\u042d\b\u0094\2\2\u042d\u0128"+
+		"\3\2\2\2\64\2\u0280\u0284\u0288\u028c\u0290\u0297\u029c\u029e\u02a4\u02a8"+
+		"\u02ac\u02b2\u02b7\u02c1\u02c5\u02cb\u02cf\u02d7\u02db\u02e1\u02eb\u02ef"+
+		"\u02f5\u02f9\u02fe\u0301\u0304\u0309\u030c\u0311\u0316\u031e\u0329\u032d"+
+		"\u0332\u0336\u0346\u0350\u0356\u035d\u0361\u0367\u0374\u03f5\u03fe\u0406"+
+		"\u0411\u041b\u0429\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);
+		}
+	}
+}

antlr/Java8Lexer.tokens

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

antlr/makefile

@@ -0,0 +1,4 @@
+all:
+	java -jar ./antlr-4.4-complete.jar Java8.g4
+	javac -cp ./antlr-4.4-complete.jar:. *.java
+

bin/log4j.xml

@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
+
+<log4j:configuration xmlns:log4j='http://jakarta.apache.org/log4j/'>
+
+ <appender name="CONSOLE" class="de.dhbwstuttgart.logger.ConsoleAppender">
+    <param name="Target" value="System.out"/>
+
+    <layout class="de.dhbwstuttgart.logger.PatternLayout">
+      <param name="ConversionPattern" value="%-15C{1} %-5p [%-9c] %m%n"/>
+    </layout>	    
+ </appender>
+
+ <logger name="codegen">
+       <level value="INFO"/>
+       <appender-ref ref="CONSOLE"/>
+ </logger>
+
+ <logger name="parser">
+       <level value="OFF"/>
+       <appender-ref ref="CONSOLE"/>
+ </logger>
+ 
+  <logger name="inference">
+       <level value="WARN"/>
+       <appender-ref ref="CONSOLE"/>
+ </logger>
+ 
+
+ <logger name="bytecode">
+       <level value="INFO"/>
+       <appender-ref ref="CONSOLE"/>
+ </logger>
+
+</log4j:configuration>

bin/log4jTesting.xml

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
+
+<log4j:configuration xmlns:log4j='http://jakarta.apache.org/log4j/'>
+
+ <appender name="CONSOLE" class="de.dhbwstuttgart.logger.ConsoleAppender">
+    <param name="Target" value="System.out"/>
+
+    <layout class="de.dhbwstuttgart.logger.PatternLayout">
+      <param name="ConversionPattern" value="%-15C{1} %-5p [%-9c] %m%n"/>
+    </layout>	    
+ </appender>
+
+ <logger name="trtest">
+       <level value="DEBUG"/>
+       <appender-ref ref="CONSOLE"/>
+ </logger>
+ 
+  <logger name="funcTest">
+       <level value="DEBUG"/>
+       <appender-ref ref="CONSOLE"/>
+ </logger>
+
+</log4j:configuration>

bin/parser/BoundedParameter.jav

@@ -0,0 +1,3 @@
+class Matrix{
+	<A extends B, C extends B> String op = "String";
+}

bin/parser/FieldInitializationTest.jav

@@ -0,0 +1,3 @@
+class FieldInitializationTest{
+	String var = "hallo";
+}

bin/parser/GenericFieldVarTest.jav

@@ -0,0 +1,3 @@
+class Test{
+<A> A var;
+}

bin/parser/ImportTest.jav

@@ -0,0 +1,4 @@
+import java.util.*;
+
+class ImportTest{
+}

doc/LambdaJavadoc/de/dhbwstuttgart/parser/JavaClassName.html

@@ -100,7 +100,7 @@ var activeTableTab = "activeTableTab";
 <li>java.lang.Object</li>
 <li>
 <ul class="inheritance">
-<li>de.dhbwstuttgart.typecheck.JavaClassName</li>
+<li>de.dhbwstuttgart.parser.JavaClassName</li>
 </ul>
 </li>
 </ul>

doc/LambdaJavadoc/de/dhbwstuttgart/parser/class-use/JavaClassName.html

@@ -3,7 +3,7 @@
 <html lang="de">
 <head>
 <!-- Generated by javadoc (1.8.0_05) on Tue May 12 19:56:24 CEST 2015 -->
-<title>Uses of Class de.dhbwstuttgart.typecheck.JavaClassName</title>
+<title>Uses of Class de.dhbwstuttgart.parser.JavaClassName</title>
 <meta name="date" content="2015-05-12">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
 <script type="text/javascript" src="../../../../script.js"></script>
@@ -70,7 +70,7 @@
 </a></div>
 <!-- ========= END OF TOP NAVBAR ========= -->
 <div class="header">
-<h2 title="Uses of Class de.dhbwstuttgart.typecheck.JavaClassName" class="title">Uses of Class<br>de.dhbwstuttgart.parser.JavaClassName</h2>
+<h2 title="Uses of Class de.dhbwstuttgart.parser.JavaClassName" class="title">Uses of Class<br>de.dhbwstuttgart.parser.JavaClassName</h2>
 </div>
 <div class="classUseContainer">
 <ul class="blockList">

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/BasicAssumptionClass.html

@@ -69,9 +69,9 @@
 <ul class="subNavList">
 <li>Summary:&nbsp;</li>
 <li>Nested&nbsp;|&nbsp;</li>
-<li><a href="#fields.inherited.from.class.de.dhbwstuttgart.syntaxtree.ClassOrInterface">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#fields.inherited.from.class.de.dhbwstuttgart.syntaxtree.Class">Field</a>&nbsp;|&nbsp;</li>
 <li><a href="#constructor.summary">Constr</a>&nbsp;|&nbsp;</li>
-<li><a href="#methods.inherited.from.class.de.dhbwstuttgart.syntaxtree.ClassOrInterface">Method</a></li>
+<li><a href="#methods.inherited.from.class.de.dhbwstuttgart.syntaxtree.Class">Method</a></li>
 </ul>
 <ul class="subNavList">
 <li>Detail:&nbsp;</li>
@@ -100,7 +100,7 @@
 <li><a href="../../../de/dhbwstuttgart/syntaxtree/GTVDeclarationContext.html" title="class in de.dhbwstuttgart.syntaxtree">de.dhbwstuttgart.syntaxtree.GTVDeclarationContext</a></li>
 <li>
 <ul class="inheritance">
-<li><a href="../../../de/dhbwstuttgart/syntaxtree/Class.html" title="class in de.dhbwstuttgart.syntaxtree">de.dhbwstuttgart.syntaxtree.ClassOrInterface</a></li>
+<li><a href="../../../de/dhbwstuttgart/syntaxtree/Class.html" title="class in de.dhbwstuttgart.syntaxtree">de.dhbwstuttgart.syntaxtree.Class</a></li>
 <li>
 <ul class="inheritance">
 <li>de.dhbwstuttgart.syntaxtree.BasicAssumptionClass</li>
@@ -137,7 +137,7 @@ extends <a href="../../../de/dhbwstuttgart/syntaxtree/Class.html" title="class i
 </a>
 <h3>Field Summary</h3>
 <ul class="blockList">
-<li class="blockList"><a name="fields.inherited.from.class.de.dhbwstuttgart.syntaxtree.ClassOrInterface">
+<li class="blockList"><a name="fields.inherited.from.class.de.dhbwstuttgart.syntaxtree.Class">
 <!--   -->
 </a>
 <h3>Fields inherited from class&nbsp;de.dhbwstuttgart.syntaxtree.<a href="../../../de/dhbwstuttgart/syntaxtree/Class.html" title="class in de.dhbwstuttgart.syntaxtree">Class</a></h3>
@@ -173,7 +173,7 @@ extends <a href="../../../de/dhbwstuttgart/syntaxtree/Class.html" title="class i
 </a>
 <h3>Method Summary</h3>
 <ul class="blockList">
-<li class="blockList"><a name="methods.inherited.from.class.de.dhbwstuttgart.syntaxtree.ClassOrInterface">
+<li class="blockList"><a name="methods.inherited.from.class.de.dhbwstuttgart.syntaxtree.Class">
 <!--   -->
 </a>
 <h3>Methods inherited from class&nbsp;de.dhbwstuttgart.syntaxtree.<a href="../../../de/dhbwstuttgart/syntaxtree/Class.html" title="class in de.dhbwstuttgart.syntaxtree">Class</a></h3>
@@ -287,9 +287,9 @@ extends <a href="../../../de/dhbwstuttgart/syntaxtree/Class.html" title="class i
 <ul class="subNavList">
 <li>Summary:&nbsp;</li>
 <li>Nested&nbsp;|&nbsp;</li>
-<li><a href="#fields.inherited.from.class.de.dhbwstuttgart.syntaxtree.ClassOrInterface">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#fields.inherited.from.class.de.dhbwstuttgart.syntaxtree.Class">Field</a>&nbsp;|&nbsp;</li>
 <li><a href="#constructor.summary">Constr</a>&nbsp;|&nbsp;</li>
-<li><a href="#methods.inherited.from.class.de.dhbwstuttgart.syntaxtree.ClassOrInterface">Method</a></li>
+<li><a href="#methods.inherited.from.class.de.dhbwstuttgart.syntaxtree.Class">Method</a></li>
 </ul>
 <ul class="subNavList">
 <li>Detail:&nbsp;</li>

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/Class.html

@@ -106,7 +106,7 @@ var activeTableTab = "activeTableTab";
 <li><a href="../../../de/dhbwstuttgart/syntaxtree/GTVDeclarationContext.html" title="class in de.dhbwstuttgart.syntaxtree">de.dhbwstuttgart.syntaxtree.GTVDeclarationContext</a></li>
 <li>
 <ul class="inheritance">
-<li>de.dhbwstuttgart.syntaxtree.ClassOrInterface</li>
+<li>de.dhbwstuttgart.syntaxtree.Class</li>
 </ul>
 </li>
 </ul>

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/Interface.html

@@ -75,7 +75,7 @@ var activeTableTab = "activeTableTab";
 <ul class="subNavList">
 <li>Summary:&nbsp;</li>
 <li>Nested&nbsp;|&nbsp;</li>
-<li><a href="#fields.inherited.from.class.de.dhbwstuttgart.syntaxtree.ClassOrInterface">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#fields.inherited.from.class.de.dhbwstuttgart.syntaxtree.Class">Field</a>&nbsp;|&nbsp;</li>
 <li><a href="#constructor.summary">Constr</a>&nbsp;|&nbsp;</li>
 <li><a href="#method.summary">Method</a></li>
 </ul>
@@ -106,7 +106,7 @@ var activeTableTab = "activeTableTab";
 <li><a href="../../../de/dhbwstuttgart/syntaxtree/GTVDeclarationContext.html" title="class in de.dhbwstuttgart.syntaxtree">de.dhbwstuttgart.syntaxtree.GTVDeclarationContext</a></li>
 <li>
 <ul class="inheritance">
-<li><a href="../../../de/dhbwstuttgart/syntaxtree/Class.html" title="class in de.dhbwstuttgart.syntaxtree">de.dhbwstuttgart.syntaxtree.ClassOrInterface</a></li>
+<li><a href="../../../de/dhbwstuttgart/syntaxtree/Class.html" title="class in de.dhbwstuttgart.syntaxtree">de.dhbwstuttgart.syntaxtree.Class</a></li>
 <li>
 <ul class="inheritance">
 <li>de.dhbwstuttgart.syntaxtree.Interface</li>
@@ -148,7 +148,7 @@ extends <a href="../../../de/dhbwstuttgart/syntaxtree/Class.html" title="class i
 </a>
 <h3>Field Summary</h3>
 <ul class="blockList">
-<li class="blockList"><a name="fields.inherited.from.class.de.dhbwstuttgart.syntaxtree.ClassOrInterface">
+<li class="blockList"><a name="fields.inherited.from.class.de.dhbwstuttgart.syntaxtree.Class">
 <!--   -->
 </a>
 <h3>Fields inherited from class&nbsp;de.dhbwstuttgart.syntaxtree.<a href="../../../de/dhbwstuttgart/syntaxtree/Class.html" title="class in de.dhbwstuttgart.syntaxtree">Class</a></h3>
@@ -205,7 +205,7 @@ extends <a href="../../../de/dhbwstuttgart/syntaxtree/Class.html" title="class i
 </tr>
 </table>
 <ul class="blockList">
-<li class="blockList"><a name="methods.inherited.from.class.de.dhbwstuttgart.syntaxtree.ClassOrInterface">
+<li class="blockList"><a name="methods.inherited.from.class.de.dhbwstuttgart.syntaxtree.Class">
 <!--   -->
 </a>
 <h3>Methods inherited from class&nbsp;de.dhbwstuttgart.syntaxtree.<a href="../../../de/dhbwstuttgart/syntaxtree/Class.html" title="class in de.dhbwstuttgart.syntaxtree">Class</a></h3>
@@ -356,7 +356,7 @@ extends <a href="../../../de/dhbwstuttgart/syntaxtree/Class.html" title="class i
 <ul class="subNavList">
 <li>Summary:&nbsp;</li>
 <li>Nested&nbsp;|&nbsp;</li>
-<li><a href="#fields.inherited.from.class.de.dhbwstuttgart.syntaxtree.ClassOrInterface">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#fields.inherited.from.class.de.dhbwstuttgart.syntaxtree.Class">Field</a>&nbsp;|&nbsp;</li>
 <li><a href="#constructor.summary">Constr</a>&nbsp;|&nbsp;</li>
 <li><a href="#method.summary">Method</a></li>
 </ul>

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/class-use/Class.html

@@ -3,7 +3,7 @@
 <html lang="de">
 <head>
 <!-- Generated by javadoc (1.8.0_05) on Tue May 12 19:56:24 CEST 2015 -->
-<title>Uses of Class de.dhbwstuttgart.syntaxtree.ClassOrInterface</title>
+<title>Uses of Class de.dhbwstuttgart.syntaxtree.Class</title>
 <meta name="date" content="2015-05-12">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
 <script type="text/javascript" src="../../../../script.js"></script>
@@ -70,7 +70,7 @@
 </a></div>
 <!-- ========= END OF TOP NAVBAR ========= -->
 <div class="header">
-<h2 title="Uses of Class de.dhbwstuttgart.syntaxtree.ClassOrInterface" class="title">Uses of Class<br>de.dhbwstuttgart.syntaxtree.Class</h2>
+<h2 title="Uses of Class de.dhbwstuttgart.syntaxtree.Class" class="title">Uses of Class<br>de.dhbwstuttgart.syntaxtree.Class</h2>
 </div>
 <div class="classUseContainer">
 <ul class="blockList">

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/type/BoundedGenericTypeVar.html

@@ -112,7 +112,7 @@ var activeTableTab = "activeTableTab";
 <li><a href="../../../../de/dhbwstuttgart/syntaxtree/type/GenericTypeVar.html" title="class in de.dhbwstuttgart.syntaxtree.type">de.dhbwstuttgart.syntaxtree.type.GenericTypeVar</a></li>
 <li>
 <ul class="inheritance">
-<li>de.dhbwstuttgart.syntaxtree.GenericTypeVar</li>
+<li>de.dhbwstuttgart.syntaxtree.type.BoundedGenericTypeVar</li>
 </ul>
 </li>
 </ul>

doc/LambdaJavadoc/de/dhbwstuttgart/syntaxtree/type/class-use/BoundedGenericTypeVar.html

@@ -3,7 +3,7 @@
 <html lang="de">
 <head>
 <!-- Generated by javadoc (1.8.0_05) on Tue May 12 19:56:24 CEST 2015 -->
-<title>Uses of Class de.dhbwstuttgart.syntaxtree.GenericTypeVar</title>
+<title>Uses of Class de.dhbwstuttgart.syntaxtree.type.BoundedGenericTypeVar</title>
 <meta name="date" content="2015-05-12">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
 <script type="text/javascript" src="../../../../../script.js"></script>
@@ -70,7 +70,7 @@
 </a></div>
 <!-- ========= END OF TOP NAVBAR ========= -->
 <div class="header">
-<h2 title="Uses of Class de.dhbwstuttgart.syntaxtree.GenericTypeVar" class="title">Uses of Class<br>de.dhbwstuttgart.syntaxtree.BoundedGenericTypeVar</h2>
+<h2 title="Uses of Class de.dhbwstuttgart.syntaxtree.type.BoundedGenericTypeVar" class="title">Uses of Class<br>de.dhbwstuttgart.syntaxtree.type.BoundedGenericTypeVar</h2>
 </div>
 <div class="classUseContainer">
 <ul class="blockList">

doc/LambdaJavadoc/de/dhbwstuttgart/typeinference/FunNInterface.html

@@ -75,7 +75,7 @@ var activeTableTab = "activeTableTab";
 <ul class="subNavList">
 <li>Summary:&nbsp;</li>
 <li>Nested&nbsp;|&nbsp;</li>
-<li><a href="#fields.inherited.from.class.de.dhbwstuttgart.syntaxtree.ClassOrInterface">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#fields.inherited.from.class.de.dhbwstuttgart.syntaxtree.Class">Field</a>&nbsp;|&nbsp;</li>
 <li><a href="#constructor.summary">Constr</a>&nbsp;|&nbsp;</li>
 <li><a href="#method.summary">Method</a></li>
 </ul>
@@ -106,7 +106,7 @@ var activeTableTab = "activeTableTab";
 <li><a href="../../../de/dhbwstuttgart/syntaxtree/GTVDeclarationContext.html" title="class in de.dhbwstuttgart.syntaxtree">de.dhbwstuttgart.syntaxtree.GTVDeclarationContext</a></li>
 <li>
 <ul class="inheritance">
-<li><a href="../../../de/dhbwstuttgart/syntaxtree/Class.html" title="class in de.dhbwstuttgart.syntaxtree">de.dhbwstuttgart.syntaxtree.ClassOrInterface</a></li>
+<li><a href="../../../de/dhbwstuttgart/syntaxtree/Class.html" title="class in de.dhbwstuttgart.syntaxtree">de.dhbwstuttgart.syntaxtree.Class</a></li>
 <li>
 <ul class="inheritance">
 <li>de.dhbwstuttgart.typeinference.FunNInterface</li>
@@ -148,7 +148,7 @@ extends <a href="../../../de/dhbwstuttgart/syntaxtree/Class.html" title="class i
 </a>
 <h3>Field Summary</h3>
 <ul class="blockList">
-<li class="blockList"><a name="fields.inherited.from.class.de.dhbwstuttgart.syntaxtree.ClassOrInterface">
+<li class="blockList"><a name="fields.inherited.from.class.de.dhbwstuttgart.syntaxtree.Class">
 <!--   -->
 </a>
 <h3>Fields inherited from class&nbsp;de.dhbwstuttgart.syntaxtree.<a href="../../../de/dhbwstuttgart/syntaxtree/Class.html" title="class in de.dhbwstuttgart.syntaxtree">Class</a></h3>
@@ -205,7 +205,7 @@ extends <a href="../../../de/dhbwstuttgart/syntaxtree/Class.html" title="class i
 </tr>
 </table>
 <ul class="blockList">
-<li class="blockList"><a name="methods.inherited.from.class.de.dhbwstuttgart.syntaxtree.ClassOrInterface">
+<li class="blockList"><a name="methods.inherited.from.class.de.dhbwstuttgart.syntaxtree.Class">
 <!--   -->
 </a>
 <h3>Methods inherited from class&nbsp;de.dhbwstuttgart.syntaxtree.<a href="../../../de/dhbwstuttgart/syntaxtree/Class.html" title="class in de.dhbwstuttgart.syntaxtree">Class</a></h3>
@@ -362,7 +362,7 @@ extends <a href="../../../de/dhbwstuttgart/syntaxtree/Class.html" title="class i
 <ul class="subNavList">
 <li>Summary:&nbsp;</li>
 <li>Nested&nbsp;|&nbsp;</li>
-<li><a href="#fields.inherited.from.class.de.dhbwstuttgart.syntaxtree.ClassOrInterface">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#fields.inherited.from.class.de.dhbwstuttgart.syntaxtree.Class">Field</a>&nbsp;|&nbsp;</li>
 <li><a href="#constructor.summary">Constr</a>&nbsp;|&nbsp;</li>
 <li><a href="#method.summary">Method</a></li>
 </ul>

examples/OldExamples/hama/Add.jav

@@ -0,0 +1,7 @@
+class Add
+{
+	int add(int a, int b)
+	{
+		return a + b;
+	}
+}

examples/OldExamples/hama/AddMain.jav

@@ -0,0 +1,8 @@
+class AddMain
+{
+	public static void main(String[] args)
+	{
+		Add a = new Add();
+		System.out.println("Addition: 3+4= " + a.add(3, 4));
+	}
+}

examples/OldExamples/hama/Empty.jav

@@ -0,0 +1,4 @@
+class Empty
+{
+	
+}

examples/OldExamples/hama/EmptyMain.jav

@@ -0,0 +1,8 @@
+public class EmptyMain
+{
+	public static void main(String[] args)
+	{
+		Empty e = new Empty();
+		System.out.println("finished");
+	}
+}

examples/OldExamples/hama/Ergebnis.jav

@@ -0,0 +1,18 @@
+class Ergebnis
+{
+	int zahl1;
+	int zahl2;
+	int erg;
+	
+	void berechne(int a, int b)
+	{
+		zahl1 = a;
+		zahl2 = b;
+		erg = zahl1 + zahl2;
+	}
+	
+	int ergebnis()
+	{
+		return erg;
+	}
+}

examples/OldExamples/hama/ErgebnisMain.jav

@@ -0,0 +1,9 @@
+public class ErgebnisMain
+{
+	public static void main(String[] args)
+	{
+		Ergebnis e = new Ergebnis();
+		e.berechne(2, 3);
+		System.out.println("Addition: 2+3= " + e.ergebnis());
+	}
+}

examples/OldExamples/hama/Setze.jav

@@ -0,0 +1,9 @@
+class Setze
+{
+	int zahl;
+	
+	void setze()
+	{
+		zahl = 555;
+	}
+}

examples/OldExamples/hama/SetzeMain.jav

@@ -0,0 +1,9 @@
+public class SetzeMain
+{
+	public static void main(String[] args)
+	{
+		Setze s = new Setze();
+		s.setze();
+		System.out.println("finished");
+	}
+}

examples/OldExamples/hama/StoreSomethingObj.jav

@@ -0,0 +1,14 @@
+class StoreSomethingObj
+{
+	Object something;
+
+	Object get()
+	{
+		return something;
+	}
+
+	void set(Object some)
+	{
+		something = some;
+	}
+}

examples/OldExamples/hama/StoreSomethingObjCon.jav

@@ -0,0 +1,19 @@
+class StoreSomethingObjCon
+{
+	Object something;
+
+	StoreSomethingObjCon(Object some)
+	{
+		something = some;
+	}
+
+	Object get()
+	{
+		return something;
+	}
+
+	void set(Object some)
+	{
+		something = some;
+	}
+}

examples/OldExamples/hama/StoreSomethingObjMain.jav

@@ -0,0 +1,15 @@
+public class StoreSomethingObjMain
+{
+	public static void main(String[] args)
+	{
+		StoreSomethingObjCon a = new StoreSomethingObjCon("I'm a String");
+		System.out.println(a.get());
+		a.set("new String");
+		System.out.println(a.get());
+		StoreSomethingObj b = new StoreSomethingObj();
+		b.set("I'm var b");
+		System.out.println(b.get());
+		b.set("new b");
+		System.out.println(b.get());
+	}
+}

examples/OldExamples/hama/StoreSomethingPar.jav

@@ -0,0 +1,14 @@
+class StoreSomethingPar<A>
+{
+	A something;
+
+	A get()
+	{
+		return something;
+	}
+
+	void set(A some)
+	{
+		something = some;
+	}
+}

examples/OldExamples/hama/StoreSomethingParCon.jav

@@ -0,0 +1,19 @@
+class StoreSomethingParCon<A>
+{
+	A something;
+
+	StoreSomethingParCon(A some)
+	{
+		something = some;
+	}
+
+	A get()
+	{
+		return something;
+	}
+
+	void set(A some)
+	{
+		something = some;
+	}
+}

examples/OldExamples/hama/StoreSomethingParMain.jav

@@ -0,0 +1,15 @@
+public class MStoreSomethingParMain
+{
+	public static void main(String[] args)
+	{
+		StoreSomethingParCon<String> a = new StoreSomethingParCon("I'm a String");
+		System.out.println(a.get());
+		a.set("new String");
+		System.out.println(a.get());
+		StoreSomethingPar<String> b = new StoreSomethingPar();
+		b.set("I'm var b");
+		System.out.println(b.get());
+		b.set("new b");
+		System.out.println(b.get());
+	}
+}

examples/OldExamples/hama/StoreSomethingParMainTrick.jav

@@ -0,0 +1,15 @@
+public class StoreSomethingParMainTrick
+{
+	public static void main(String[] args)
+	{
+		StoreSomethingParCon a = new StoreSomethingParCon("I'm a String");
+		System.out.println(a.get());
+		a.set("new String");
+		System.out.println(a.get());
+		StoreSomethingPar b = new StoreSomethingPar();
+		b.set("I'm var b");
+		System.out.println(b.get());
+		b.set("new b");
+		System.out.println(b.get());
+	}
+}

examples/OldExamples/hama/StoreSomethingStr.jav

@@ -0,0 +1,14 @@
+class StoreSomethingStr
+{
+	String something;
+
+	String get()
+	{
+		return something;
+	}
+
+	void set(String some)
+	{
+		something = some;
+	}
+}

examples/OldExamples/hama/StoreSomethingStrCon.jav

@@ -0,0 +1,19 @@
+class StoreSomethingStrCon
+{
+	String something;
+
+	StoreSomethingStrCon(String some)
+	{
+		something = some;
+	}
+
+	String get()
+	{
+		return something;
+	}
+
+	void set(String some)
+	{
+		something = some;
+	}
+}

examples/OldExamples/hama/StoreSomethingStrMain.jav

@@ -0,0 +1,15 @@
+public class StoreSomethingStrMain
+{
+	public static void main(String[] args)
+	{
+		StoreSomethingStrCon a = new StoreSomethingStrCon("I'm a String");
+		System.out.println(a.get());
+		a.set("new String");
+		System.out.println(a.get());
+		StoreSomethingStr b = new StoreSomethingStr();
+		b.set("I'm var b");
+		System.out.println(b.get());
+		b.set("new b");
+		System.out.println(b.get());
+	}
+}

examples/OldExamples/hama/Toggle1.jav

@@ -0,0 +1,16 @@
+class Toggle1
+{
+	boolean toggle(boolean b)
+	{
+		if(b)
+		{
+			b = false;
+			return b;
+		}
+		else
+		{
+			b = true;
+			return b;
+		}
+	}
+}

examples/OldExamples/hama/Toggle2.jav

@@ -0,0 +1,15 @@
+class Toggle2
+{
+	boolean toggle(boolean b)
+	{
+		if(b)
+		{
+			b = false;
+		}
+		else
+		{
+			b = true;
+		}
+		return b;
+	}
+}

examples/OldExamples/hama/Toggle3.jav

@@ -0,0 +1,25 @@
+public class Toggle3
+{
+	boolean toggle(boolean b)
+	{
+		if(b)
+		{
+			b = false;
+			if(true)
+			{
+				return b;
+			}
+			b = false;
+		}
+		else
+		{
+			b = true;
+			if(true)
+			{
+				return b;
+			}
+			b = true;
+		}
+		return b;
+	}
+}

examples/OldExamples/hama/ToggleMain.jav

@@ -0,0 +1,18 @@
+public class ToggleMain
+{
+	public static void main(String[] args)
+	{
+		Toggle1 t1 = new Toggle1();
+		boolean b1 = false;
+		System.out.println("b1: " + b1);
+		System.out.println("b1 getoggelt: " + t1.toggle(b1));
+		Toggle2 t2 = new Toggle2();
+		boolean b2 = false;
+		System.out.println("b2: " + b2);
+		System.out.println("b2 getoggelt: " + t2.toggle(b2));
+		Toggle3 t3 = new Toggle3();
+		boolean b3 = false;
+		System.out.println("b3: " + b3);
+		System.out.println("b3 getoggelt: " + t3.toggle(b3));
+	}
+}

examples/OldExamples/hama/test1.jav

@@ -0,0 +1,37 @@
+class Test
+{
+}
+
+
+
+class List1<A, B>
+{
+	A ab;
+	C da;
+	
+	B bu()
+	{
+	}
+}
+
+
+
+class Listst2<A>
+{
+	A object = null;
+	Listst2<A> next = new Listst2();
+}
+
+
+
+class MainKlasse<x> extends List1<List1<Test, Test>, List1<Test, Test>>
+{
+	x ra;
+	List1<Test> li = new List1();
+	
+	void main()
+	{
+		List1<Test, List1<Test, Test>> si = new List1();
+		si.bu();
+	}
+}

examples/OldExamples/hama/test11.jav

@@ -0,0 +1,37 @@
+class Test
+{
+}
+
+
+
+class List1<A, B>
+{
+	A ab;
+	C da;
+	
+	B bu()
+	{
+	}
+}
+
+
+
+class Listst2<A>
+{
+	A object = null;
+	Listst2<A> next = new Listst2();
+}
+
+
+
+class MainKlasse<x> extends List1<List1<Test, Test>, List1<Test, Test>>
+{
+	x ra;
+	List1<Test, Test> li = new List1();
+	
+	void main()
+	{
+		List1<Test, List1<Test, Test>> si = new List1();
+		si.bu();
+	}
+}

examples/OldExamples/hama/test1o.jav

@@ -0,0 +1,20 @@
+class test{}
+class list<A,B>{
+	A a;
+	B b(){}
+	C d;
+}
+
+class main<x> extends list<list<test,test>,list<test,test>> {
+  x r;
+  list <test>l = new list();
+  void main(){
+    list<test,list<test,test>>s= new list();
+    s.b();
+    }
+}
+
+class List<A>{
+        List <A>next = new List();
+	A object = null;
+}

examples/OldExamples/hama/test2.jav

@@ -0,0 +1,42 @@
+class Inte
+{
+}
+
+
+
+class Liststst3<A>
+{
+	A ab = null;
+	Liststst3<A> next = new Liststst3();
+	
+	void insert(A elem)
+	{
+		if(ab = null)
+		{
+			ab = elem;
+		}
+		else
+		{
+			next.insert(elem);
+		}
+	}
+	
+	void get(A elem)
+	{
+		System.out.println(elem);
+		next.get(elem);
+	}
+}
+
+
+
+class MainClass extends Liststst3<Liststst3<Inte>>
+{
+	Liststst3 <Inte> li = new Liststst3();
+	
+	void main()
+	{
+		Liststst3<Inte> sa = new Liststst3(), <Inte> li = new Liststst3();
+		Inte in = new Inte();
+	}
+}

examples/OldExamples/hama/test22.jav

@@ -0,0 +1,42 @@
+class Inte
+{
+}
+
+
+
+class Liststst3<A>
+{
+	A ab = null;
+	Liststst3<A> next = new Liststst3();
+	
+	void insert(A elem)
+	{
+		if(ab == null)
+		{
+			ab = elem;
+		}
+		else
+		{
+			next.insert(elem);
+		}
+	}
+	
+	void get(A elem)
+	{
+		System.out.println(elem);
+		next.get(elem);
+	}
+}
+
+
+
+class MainClass extends Liststst3<Liststst3<Inte>>
+{
+	Liststst3 <Inte> li = new Liststst3();
+	
+	void main()
+	{
+		Liststst3<Inte> sa = new Liststst3(), <Inte> li = new Liststst3();
+		Inte in = new Inte();
+	}
+}

examples/OldExamples/hama/test2o.jav

@@ -0,0 +1,32 @@
+class INT{}
+class list<A>{
+	A a = null;
+	list<A>next = new list();
+	void insert(A elem){
+	     if(a = null){
+	        a=elem;
+	     }
+	     else{
+	       next.insert(elem);
+	     }
+	}
+	void get(A elem){
+	     
+	     	System.out.println(elem);
+             
+	      next.get(elem);
+
+	}
+}
+
+class main extends list<list<INT>> {
+  
+  list <INT>l = new list();
+  void main(){
+    list<INT>s= new list(), <INT>l = new list();
+    INT i = new INT();
+    }
+}
+
+
+

examples/OldExamples/hama/test3.jav

@@ -0,0 +1,29 @@
+class Listststst4<A>
+{
+	A objec = null;
+	Listststst4<A> next = new Listststst4();
+	
+	void insert(A obj)
+	{
+		if(this.objec == null)
+		{
+			this.objec = obj;
+		}
+		else
+		{
+			this.next.insert(obj);
+		}
+	}
+	
+	A getObjectAt(int n)
+	{
+		if(n == 0)
+		{
+			return this.objec;
+		}
+		else
+		{
+			return this.next.getObjectAt(n-1);
+		}
+	}
+}

examples/OldExamples/hama/test33.jav

@@ -0,0 +1,29 @@
+class Listststst4<A>
+{
+	A objec = null;
+	Listststst4<A> next = new Listststst4();
+		
+	void insert(A obj)
+	{
+		if(objec = null)
+		{
+			objec = obj;
+		}
+		else
+		{
+			next.insert(obj);
+		}
+	}
+	
+	A getObjectAt(int n)
+	{
+		if(n = 0)
+		{
+			return objec;
+		}
+		else
+		{
+			return next.getObjectAt(n-1);
+		}
+	}
+}

examples/OldExamples/hama/test3o.jav

@@ -0,0 +1,20 @@
+class List<A>{
+		List <A>next = new List();
+		A object = null;
+		A getObjectAt(int n){
+			if(n==0){
+				return object;
+			}
+			else{
+			return this.next.getObjectAt(n-1);
+			}
+		}
+		void insert(A object){
+			if(this. Object == null){
+				this.object = object;
+			}
+			else{
+				this.next.insert(object);
+			}
+		}
+}

examples/OldExamples/otth/otth10.jav

@@ -0,0 +1,22 @@
+class otth10
+{
+    f1( a, int b )
+    {
+    }
+
+    int f3( X test )
+    {
+    }
+
+    otth10( int b, c, d )
+    {
+    }
+
+}
+
+class Test
+{
+    f5()
+    {
+    }
+}

examples/OldExamples/otth/otth11.jav

@@ -0,0 +1,10 @@
+class otth11
+{
+    f1( a, int b )
+    {
+    }
+
+    void f2( TYPEA<parameterA1, parameterA2> VA, TYPEB<parameterB> VB)
+    {
+    }
+}

examples/OldExamples/otth/otth12.jav

@@ -0,0 +1,26 @@
+class AbstractList<A>
+{
+    A a = null;
+}
+
+class Vektor<B> extends AbstractList<B>
+{
+    B a = null;
+}
+
+class Stapel<A> extends Vektor<A>
+{
+    A a = null;
+}
+
+class IntZahl
+{
+}
+
+class Bool
+{
+}
+
+class Main
+{
+}

examples/OldExamples/otth/otth13.jav

@@ -0,0 +1,13 @@
+class AbstractList<A, B>
+{
+    A a = null;
+    B b = null;
+}
+
+
+class Vektor<B, C> extends AbstractList<A, B>
+{
+    A a = null;
+    B b = null;
+    C c = null;
+}

examples/OldExamples/otth/otth14.jav

@@ -0,0 +1,11 @@
+class X<B>
+{
+    B a = null;
+}
+
+class otth14
+{
+    void f1( X<A> a )
+    {
+    }
+}

examples/OldExamples/otth/otth15.jav

@@ -0,0 +1,43 @@
+class List<A>
+{
+    A a = null;
+}
+
+class Vektor<A> extends List<A>
+{
+    A a = null;
+}
+
+class Stack<A> extends Vektor<A>
+{
+    A a = null;
+}
+
+class ClassB<A, B, C>
+{
+    A a = null;
+    B b = null;
+    C c = null;
+}
+
+class ClassA<A, B, C> extends ClassB<C, B, A>
+{
+    A a = null;
+    B b = null;
+    C c = null;
+}
+
+class Int
+{
+}
+
+class Bool
+{
+}
+
+class otth15
+{
+    void f1( X<A> a )
+    {
+    }
+}

examples/OldExamples/otth/otth16.jav

@@ -0,0 +1,38 @@
+class List<A>
+{
+    A a = null;
+}
+
+class AbstractList<A> extends List<A>
+{
+    A a = null;
+}
+
+class Vektor<A> extends AbstractList<A>
+{
+    A a = null;
+}
+
+class Stack<A> extends Vektor<A>
+{
+    A a = null;
+}
+
+class Objekt
+{
+}
+
+class Int
+{
+}
+
+class Paar<A, B>
+{
+    A a = null;
+    B b = null;
+}
+
+
+class otth16
+{
+}