Merge

.classpath

@@ -9,3 +9,4 @@
 	<classpathentry kind="lib" path="lib/bcel-5.2.jar"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>
+

src/de/dhbwstuttgart/core/MyCompiler.java

@@ -864,7 +864,9 @@ public class MyCompiler implements MyCompilerAPI
 		 * - wird der Rückgabetyp von generateBytecode in MyCompiler geändert, so muss auch der Rückgabetyp im Interface MyCompilerAPI geändert werden
 		 */
 		try {
-			return this.m_AbstractSyntaxTree.firstElement().KlassenVektor.firstElement().genByteCode();
+			SourceFile parsedFile = this.m_AbstractSyntaxTree.firstElement();
+			Class parsedClass = parsedFile.KlassenVektor.firstElement();
+			return parsedClass.genByteCode();
 		} catch (IOException e) {
 			e.printStackTrace();
 			return null;

src/de/dhbwstuttgart/syntaxtree/Class.java

@@ -16,9 +16,9 @@ import org.apache.bcel.generic.InstructionList;
 import org.apache.bcel.generic.MethodGen;
 
 import de.dhbwstuttgart.typeinference.Menge;
-
 import de.dhbwstuttgart.logger.Logger;
 import de.dhbwstuttgart.logger.Section;
+import de.dhbwstuttgart.logger.SectionLogger;
 import de.dhbwstuttgart.core.AClassOrInterface;
 import de.dhbwstuttgart.core.IItemWithOffset;
 import de.dhbwstuttgart.parser.JavaClassName;
@@ -37,13 +37,16 @@ import de.dhbwstuttgart.typeinference.*;
 import de.dhbwstuttgart.typeinference.assumptions.ClassAssumption;
 import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 import de.dhbwstuttgart.typeinference.exceptions.DebugException;
+import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
 import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
 import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertPoint;
 import de.dhbwstuttgart.typeinference.unify.FC_TTO;
 import de.dhbwstuttgart.typeinference.unify.Unify;
+
 import org.apache.bcel.generic.*;
 import org.apache.bcel.classfile.*;
 import org.apache.bcel.*;
+
 import java.io.*;
 
 
@@ -57,8 +60,8 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I
      * Log4j - Loggerinstanzen
      */
     protected static Logger inferencelog = Logger.getLogger("inference");
-    //protected static Logger codegenlog = Logger.getLogger("codegen");
+    protected static Logger codegenlog = Logger.getLogger("codegen");
-    //protected static Logger parserlog = Logger.getLogger("parser");
+    protected static Logger parserlog = Logger.getLogger("parser");
     protected UsedId pkgName;
     protected Modifiers modifiers;
     protected String name;
@@ -70,33 +73,26 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I
     //Method created with BCEL to generate ByteCode
     public ByteCodeResult genByteCode() throws IOException {
     	    	
-    	ByteCodeResult code = new ByteCodeResult();
+    	SectionLogger logger = Logger.getSectionLogger(this.getClass().getName(), Section.CODEGEN);
+    	logger.debug("Test");
     	
-    	_cg = new ClassGen(pkgName.get_Name() + "/" + name, superClass.get_Name(), name + ".java", Constants.ACC_PUBLIC , new String[] {  }); //new String necessary?
+    	if(pkgName != null)throw new NotImplementedException();
+    	_cg = new ClassGen(name, superClass.get_Name(), name + ".java", Constants.ACC_PUBLIC , new String[] {  }); //new String necessary?
         _cp = _cg.getConstantPool();
         _factory = new InstructionFactory(_cg, _cp);
-    	ByteArrayOutputStream out = new ByteArrayOutputStream(); 
         
-        InstructionList il = new InstructionList();
+    	for(Field field : this.fielddecl){
-	    MethodGen method = new MethodGen(Constants.ACC_PUBLIC, org.apache.bcel.generic.Type.VOID, org.apache.bcel.generic.Type.NO_ARGS, new String[] {  }, "<init>", pkgName.get_Name() + "." + name, il, _cp);
+        	field.genByteCode(_cg);
-
+        }
-	    InstructionHandle ih_0 = il.append(_factory.createLoad(org.apache.bcel.generic.Type.OBJECT, 0)); //creates Constructor
-	    il.append(_factory.createInvoke("java.lang.Object", "<init>", org.apache.bcel.generic.Type.VOID, org.apache.bcel.generic.Type.NO_ARGS, Constants.INVOKESPECIAL));
-	    InstructionHandle ih_4 = il.append(_factory.createReturn(org.apache.bcel.generic.Type.VOID)); //creates Constructor
-	    method.setMaxStack();
-	    method.setMaxLocals();
-	    _cg.addMethod(method.getMethod());
-	    il.dispose();
-	    _cg.getJavaClass().dump(out);
-	    code.attach(out.toString());
     	
+	    ByteCodeResult code = new ByteCodeResult(_cg);
         return code;
         
-    	/*ByteCodeResult bc = new ByteCodeResult();
+    	//ByteCodeResult bc = new ByteCodeResult();
-    	_cg = new ClassGen(pkgName.get_Name() + "/" + name, superClass.get_Name(), name + ".java", Constants.ACC_PUBLIC , new String[] {  });
+    	//_cg = new ClassGen(pkgName.get_Name() + "/" + name, superClass.get_Name(), name + ".java", Constants.ACC_PUBLIC , new String[] {  });
     //_cg zurückgeben
-    	bc.append(BCELByteCodeOutput);
+    	//bc.append(BCELByteCodeOutput);
-    	return _cg;*/
+    	//return _cg;
     }
 
     private Menge<Type> superif = new Menge<Type>();

src/de/dhbwstuttgart/syntaxtree/Constructor.java

@@ -1,7 +1,15 @@
 package de.dhbwstuttgart.syntaxtree;
 
-import de.dhbwstuttgart.typeinference.Menge;
+import org.apache.bcel.Constants;
+import org.apache.bcel.classfile.ConstantPool;
+import org.apache.bcel.generic.ClassGen;
+import org.apache.bcel.generic.ConstantPoolGen;
+import org.apache.bcel.generic.InstructionFactory;
+import org.apache.bcel.generic.InstructionHandle;
+import org.apache.bcel.generic.InstructionList;
+import org.apache.bcel.generic.MethodGen;
 
+import de.dhbwstuttgart.typeinference.Menge;
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.parser.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.misc.DeclId;
@@ -42,7 +50,30 @@ public class Constructor extends Method {
 		ret.addAssumption(new ConstructorAssumption(this, parentClass));
 		return ret;
 	}
-	/*
+	
+	@Override
+	public void genByteCode(ClassGen cg) {
+		ConstantPoolGen _cp = cg.getConstantPool();
+		//InstructionFactory _factory = new InstructionFactory(cg, _cp);
+		InstructionList il = new InstructionList(); //sollte nicht new sein sondern aus Block kommen
+		Class parentClass = this.getParentClass();
+				
+		//Hier müsste drin stehen: Kreiere einen Block, welcher ein Statement enthält, welches ein Super Statement ist.
+				
+		//TODO: Alles dynamisch gestalten
+		//init darf nur drin stehen, wenn Konstruktor;
+		methode.method = new MethodGen(Constants.ACC_PUBLIC, org.apache.bcel.generic.Type.getReturnType(methode.getType().get_Name()), org.apache.bcel.generic.Type.NO_ARGS , new String[] {  }, "<init>", parentClass.name, il, _cp);
+		
+		methode.genByteCode(cg); //Aufrufen um Iteration über Block zu starten
+	 
+	}
+	// super statement muss drin sein
+	// stmt genByteCode + im block genByteCode implementieren & dann Hierarchie ausprobieren
+	// de.dhbw.systanxtree.stmts supercall
+	// Aufrufhierarchie: Class->Felder->Konstruktor->Methode innerhalb Konstruktor->Block->Statements (in diesem Fall nur super())->hier wird bytecode für superaufruf generiert
+	
+	
+	
 	@Override
 	public void parserPostProcessing(SyntaxTreeNode parent){
 		if(this.parameterlist != null){
@@ -54,7 +85,7 @@ public class Constructor extends Method {
 			gtv.parserPostProcessing(this);
 		}
 	}
-	*/
+	
 	@Override
 	public ConstraintsSet TYPE(TypeAssumptions ass) {
 		//super.setType(this.getParentClass().getType());
@@ -67,13 +98,13 @@ public class Constructor extends Method {
 		//throw new TypeinferenceException("Einem Konstruktor kann kein Typ zugewiesen werden", this);
 		//this.methode.setType(t);
 	}
-	/*
+	
-	public Constructor(Method methode){
+	/*public Constructor(Method methode){
 		super(methode.getOffset());
 		this.methode = methode;
 		this.setDeclIdMenge(methode.getDeclIdMenge());
 		this.methode.setType(this.methode.getParentClass().getType());
-	}
+	}*/
 
 	@Override
 	public Menge<GenericTypeVar> getGenericParameter() {
@@ -198,11 +229,11 @@ public class Constructor extends Method {
 		this.methode.setOverloadedID(overloadedID);
 	}
 
-	@Override
+	/*@Override
 	public String get_codegen_Param_Type(Menge paralist) {
 		 
 		return this.methode.get_codegen_Param_Type(paralist);
-	}
+	}*/
 
 	@Override
 	public String get_Method_Name() {
@@ -216,12 +247,12 @@ public class Constructor extends Method {
 		return this.methode.get_Type_Paralist();
 	}
 
-	@Override
+	/*@Override
 	public void codegen(ClassFile classfile, Menge paralist)
 			throws JVMCodeException {
 		 
 		this.methode.codegen(classfile, paralist);
-	}
+	}*/
 
 	@Override
 	public int getLineNumber() {
@@ -289,11 +320,11 @@ public class Constructor extends Method {
 		this.methode.set_Method_Name(string);
 	}
 
-	public ConstraintsSet TYPE(TypeAssumptions ass) {
+	/*public ConstraintsSet TYPE(TypeAssumptions ass) {
 		ConstraintsSet ret = new ConstraintsSet();
 		ret.add(this.methode.get_Block().TYPEStmt(ass));
 		return ret;
-	}
+	}*/
 
 	@Override
 	public String getTypeInformation() {
@@ -307,24 +338,24 @@ public class Constructor extends Method {
 		return this.methode.printJavaCode(resultSet);
 	}
 
-	@Override
+	/*@Override
 	public TypeAssumptions createTypeAssumptions(Class classmember) {
 		Class parentClass = this.getParentClass();
 		TypeAssumptions ret = new TypeAssumptions();
 		ret.addAssumption(new ConstructorAssumption(this, parentClass));
 		return ret;
-	}
+	}*/
 
 	@Override
 	public SyntaxTreeNode getParent(){
 		return this.methode.getParent();
 	}
 	
-	@Override
+	/*@Override
 	public void parserPostProcessing(SyntaxTreeNode parent) {
 		 
 		this.methode.parserPostProcessing(parent);
-	}
+	}*/
 
 	@Override
 	public Menge<SyntaxTreeNode> getChildren() {
@@ -332,11 +363,11 @@ public class Constructor extends Method {
 		return this.methode.getChildren();
 	}
 
-	@Override
+	/*@Override
 	public void setType(Type t) {
 		throw new TypeinferenceException("Einem Konstruktor kann kein Typ zugewiesen werden", this);
 		//this.methode.setType(t);
-	}
+	}*/
 
 	@Override
 	public Type getType() {
@@ -390,7 +421,7 @@ public class Constructor extends Method {
 	public Class getParentClass() {
 		return this.methode.getParentClass();
 	}
-	*/
+	
 	
 }
 

src/de/dhbwstuttgart/syntaxtree/Field.java

@@ -1,7 +1,8 @@
 package de.dhbwstuttgart.syntaxtree;
 
-import de.dhbwstuttgart.typeinference.Menge;
+import org.apache.bcel.generic.ClassGen;
 
+import de.dhbwstuttgart.typeinference.Menge;
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.syntaxtree.misc.DeclId;
 import de.dhbwstuttgart.syntaxtree.type.GenericTypeVar;
@@ -171,4 +172,11 @@ public abstract class Field extends GTVDeclarationContext implements TypeInserta
 	public boolean isClass() {
 		return false;
 	}
+	
+	/**
+	 * Fügt das das Feld zu ClassGen hinzu
+	 * @param cg
+	 */
+	public abstract void genByteCode(ClassGen cg);
 }
+

src/de/dhbwstuttgart/syntaxtree/FieldDeclaration.java

@@ -1,7 +1,8 @@
 package de.dhbwstuttgart.syntaxtree;
 
-import de.dhbwstuttgart.typeinference.Menge;
+import org.apache.bcel.generic.ClassGen;
 
+import de.dhbwstuttgart.typeinference.Menge;
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.syntaxtree.misc.DeclId;
 import de.dhbwstuttgart.syntaxtree.statement.Expr;
@@ -157,4 +158,16 @@ public class FieldDeclaration extends Field{
 		if(this.getWert()!=null)this.getWert().wandleRefTypeAttributes2GenericAttributes(paralist, new Menge<GenericTypeVar>()); //FieldDeclaration hat keine Generischen Variablen, daher leere Liste übergeben
 	}
 
+	@Override
+	public void genByteCode(ClassGen cg) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	/*@Override
+	public void genByteCode(ClassGen cg) {
+		// TODO Auto-generated method stub
+		
+	}*/
+
 }

src/de/dhbwstuttgart/syntaxtree/Method.java

@@ -1,14 +1,22 @@
 // ino.module.Method.8564.package 
 package de.dhbwstuttgart.syntaxtree;
+
 // ino.end
 // ino.module.Method.8564.import 
 import java.util.Enumeration;
 import java.util.Hashtable;
 import java.util.Iterator;
+
+import org.apache.bcel.Constants;
+import org.apache.bcel.generic.ClassGen;
+import org.apache.bcel.generic.ConstantPoolGen;
+import org.apache.bcel.generic.InstructionFactory;
+import org.apache.bcel.generic.InstructionHandle;
+import org.apache.bcel.generic.InstructionList;
+import org.apache.bcel.generic.MethodGen;
+
 import de.dhbwstuttgart.typeinference.Menge;
-
 import de.dhbwstuttgart.logger.Logger;
-
 import de.dhbwstuttgart.core.IItemWithOffset;
 import de.dhbwstuttgart.core.MyCompiler;
 import de.dhbwstuttgart.myexception.JVMCodeException;
@@ -19,6 +27,7 @@ import de.dhbwstuttgart.syntaxtree.misc.DeclId;
 import de.dhbwstuttgart.syntaxtree.modifier.Modifiers;
 import de.dhbwstuttgart.syntaxtree.statement.Block;
 import de.dhbwstuttgart.syntaxtree.statement.Return;
+import de.dhbwstuttgart.syntaxtree.statement.Statement;
 import de.dhbwstuttgart.syntaxtree.type.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.Type;
@@ -34,13 +43,12 @@ import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
 import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertPoint;
 
-
-
-
 // ino.class.Method.23482.declaration 
 /**
- * Stellt eine Methode dar.
+ * Stellt eine Methode dar. Problem: Parser kann nicht zwischen Methode und
- * Problem: Parser kann nicht zwischen Methode und Konstruktor unterscheiden. Daher kann diese Klasse beides sein. Dies wird mit dem ParserPostProcessing behoben.
+ * Konstruktor unterscheiden. Daher kann diese Klasse beides sein. Dies wird mit
+ * dem ParserPostProcessing behoben.
+ * 
  * @author janulrich
  *
  */
@@ -60,17 +68,17 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	// ino.attribute.returntype.23497.declaration
 	private Type returntype;
 	// ino.end
-    
+	protected MethodGen method;
 	// ino.attribute.genericMethodParameters.23500.decldescription type=javadoc
 	/**
-     * HOTI 4.5.06
+	 * HOTI 4.5.06 Dieser Vektor beinhaltet alle Generischen Typen und v.a. die
-     * Dieser Vektor beinhaltet alle Generischen Typen und v.a. die
+	 * F-Bounded-Generics, die die Methode besitzt size()==0, falls es keine
-     * F-Bounded-Generics, die die Methode besitzt
+	 * gibt
-     * size()==0, falls es keine gibt
 	 */
 	// ino.end
 	// ino.attribute.genericMethodParameters.23500.declaration
-    //private Menge<GenericTypeVar> genericMethodParameters=new Menge<GenericTypeVar>();
+	// private Menge<GenericTypeVar> genericMethodParameters=new
+	// Menge<GenericTypeVar>();
 	// ino.end
 
 	// ino.attribute.overloadedID.23503.declaration
@@ -85,24 +93,26 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	// ino.attribute.m_LineNumber.23512.declaration
 	private int m_LineNumber = MyCompiler.NO_LINENUMBER;
 	// ino.end
-    private int m_Offset = -1; //hinzugef�gt hoth: 07.04.2006
+	private int m_Offset = -1; // hinzugef�gt hoth: 07.04.2006
 	// ino.attribute.inferencelog.23515.declaration
 	protected static Logger inferencelog = Logger.getLogger("inference");
 	// ino.end
 	// ino.attribute.parserlog.23518.declaration
 	protected static Logger parserlog = Logger.getLogger("parser");
+
 	// ino.end
 
-    public Method(int offset){
+	public Method(int offset) {
 		super(offset);
 	}
 
-    public Method(String name, Type returnType, ParameterList parameterList, Block block, GenericDeclarationList gtvDeclarations, int offset){
+	public Method(String name, Type returnType, ParameterList parameterList,
+			Block block, GenericDeclarationList gtvDeclarations, int offset) {
 		this(offset);
 		/*
-    	if(parameterList != null)parameterList.parserPostProcessing(this);
+		 * if(parameterList != null)parameterList.parserPostProcessing(this);
-    	if(block != null)block.parserPostProcessing(this);
+		 * if(block != null)block.parserPostProcessing(this); if(gtvDeclarations
-    	if(gtvDeclarations != null)gtvDeclarations.parserPostProcessing(this);
+		 * != null)gtvDeclarations.parserPostProcessing(this);
 		 */
 		this.set_Method_Name(name);
 		this.setParameterList(parameterList);
@@ -112,65 +122,40 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	}
 
 	/*
-    // ino.method.setGenericMethodParameters.23521.definition 
+	 * // ino.method.setGenericMethodParameters.23521.definition public void
-    public void setGenericMethodParameters(Menge<GenericTypeVar> genericMethodParameters)
+	 * setGenericMethodParameters(Menge<GenericTypeVar> genericMethodParameters)
-    // ino.end
+	 * // ino.end // ino.method.setGenericMethodParameters.23521.body {
-    // ino.method.setGenericMethodParameters.23521.body 
+	 * this.genericMethodParameters=genericMethodParameters; } // ino.end //
-    {
+	 * ino.method.getGenericMethodParameters.23524.definition public
-        this.genericMethodParameters=genericMethodParameters;
+	 * Menge<GenericTypeVar> getGenericMethodParameters() // ino.end //
-    }
+	 * ino.method.getGenericMethodParameters.23524.body {
-    // ino.end
+	 * return(genericMethodParameters); } // ino.end
-    // ino.method.getGenericMethodParameters.23524.definition 
-    public Menge<GenericTypeVar> getGenericMethodParameters()
-    // ino.end
-    // ino.method.getGenericMethodParameters.23524.body 
-    {
-        return(genericMethodParameters);
-    }
-    // ino.end
 	 */
 	/*
-    // ino.method.sc_init_parameterlist.23530.definition 
+	 * // ino.method.sc_init_parameterlist.23530.definition public void
-    public void sc_init_parameterlist(boolean ext)
+	 * sc_init_parameterlist(boolean ext) // ino.end //
-    // ino.end
+	 * ino.method.sc_init_parameterlist.23530.body { DeclId hilf=null;
-    // ino.method.sc_init_parameterlist.23530.body 
+	 * Menge<FormalParameter> list; FormalParameter para; String typeofpara; int
-    {
+	 * i=1; if(this.getParameterList()!=null) //es gibt Parameter, dann: {
-        DeclId hilf=null;
+	 * hilf=declid.elementAt(0); if(ext)
-        Menge<FormalParameter> list;
+	 * parserlog.debug("Semantik-Check hat in Methode "
-        FormalParameter para;
+	 * +hilf.get_Name()+" bergabewerte gefunden:");
-        String typeofpara;
+	 * list=this.getParameterList().sc_get_Formalparalist(); //Menge
-        int i=1;
+	 * Formalparalist aus FormalParameterList wird zwischen gesichert
-        if(this.getParameterList()!=null) //es gibt Parameter, dann:
+	 * for(Enumeration<FormalParameter> el2=list.elements();
-        {
+	 * el2.hasMoreElements();) { para=el2.nextElement();
-        hilf=declid.elementAt(0);
+	 * typeofpara=para.getTypeName(); if(ext)
-        if(ext)
+	 * parserlog.debug("       "+i+". Parameter hat Typ "+typeofpara);
-            parserlog.debug("Semantik-Check hat in Methode "+hilf.get_Name()+" bergabewerte gefunden:"); 
+	 * types_in_parameterlist.addElement(typeofpara); //Typ der Parameter werden
-        list=this.getParameterList().sc_get_Formalparalist();  //Menge Formalparalist aus FormalParameterList wird zwischen gesichert
+	 * im Menge abgelegt i++; } } else //keine Parameter vorhanden: { if(ext) {
-        for(Enumeration<FormalParameter> el2=list.elements(); el2.hasMoreElements();)
+	 * hilf=declid.elementAt(0);
-        {
+	 * parserlog.debug("Semantik-Check hat in Methode "
-            para=el2.nextElement();
+	 * +hilf.get_Name()+" keine bergabewerte gefunden."); } } if(ext) {
-            typeofpara=para.getTypeName();
+	 * parserlog.debug("Semantik-Check hat in Methode "+hilf.get_Name()+" "+
-            if(ext)
+	 * types_in_parameterlist.size()+" bergabeparameter gefunden.");
-                parserlog.debug("       "+i+". Parameter hat Typ "+typeofpara);
+	 * parserlog.debug
-            types_in_parameterlist.addElement(typeofpara); //Typ der Parameter werden im Menge abgelegt
+	 * ("             namentlich: "+types_in_parameterlist.toString()); } } //
-            i++;
+	 * ino.end
-        }
-        }
-        else //keine Parameter vorhanden:
-        {
-        if(ext)
-        {
-            hilf=declid.elementAt(0);
-            parserlog.debug("Semantik-Check hat in Methode "+hilf.get_Name()+" keine bergabewerte gefunden.");
-        }
-        }
-        if(ext)
-        {
-            parserlog.debug("Semantik-Check hat in Methode "+hilf.get_Name()+" "+ types_in_parameterlist.size()+" bergabeparameter gefunden."); 
-            parserlog.debug("             namentlich: "+types_in_parameterlist.toString());
-        }
-    }
-    // ino.end
 	 */
 	// ino.method.getTypeName.23533.defdescription type=line
 	// Eine der beiden Funktionen ist ueberflssig. Wer sich daran strt kann die
@@ -182,11 +167,12 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	// ino.end
 	// ino.method.getTypeName.23533.body
 	{
-    if( this.getType() == null )
+		if (this.getType() == null)
 			return null;
 		else
 			return this.getType().getName();
 	}
+
 	// ino.end
 
 	// ino.method.get_Block.23536.definition
@@ -196,11 +182,14 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	{
 		return block;
 	}
+
 	// ino.end
 
 	// ino.method.setReturnType.23539.defdescription type=javadoc
 	/**
-     * <br/>Author: Jrg Buerle
+	 * <br/>
+	 * Author: Jrg Buerle
+	 * 
 	 * @param type
 	 */
 	// ino.end
@@ -211,16 +200,19 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	{
 		this.returntype = type;
 	}
+
 	// ino.end
 
 	// ino.method.set_Block.23542.definition
-    public void set_Block( Block blo)
+	public void set_Block(Block blo)
 	// ino.end
 	// ino.method.set_Block.23542.body
 	{
-    	if(blo.getType() == null)blo.setType(this.returntype);
+		if (blo.getType() == null)
+			blo.setType(this.returntype);
 		this.block = blo;
 	}
+
 	// ino.end
 
 	// ino.method.set_Modifiers.23545.definition
@@ -231,6 +223,7 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 		declid.firstElement().set_Modifiers(modif);
 		// this.modi = modif;
 	}
+
 	// ino.end
 
 	// ino.method.set_ExceptionList.23548.definition
@@ -240,30 +233,34 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	{
 		this.exceptionlist = exlist;
 	}
+
 	// ino.end
 
 	// ino.method.setParameterList.23551.definition
-    public void setParameterList( ParameterList paralist )
+	public void setParameterList(ParameterList paralist)
 	// ino.end
 	// ino.method.setParameterList.23551.body
 	{
 		this.parameterlist = paralist;
 	}
+
 	// ino.end
 
 	// ino.method.getParameterList.23554.definition
-    public ParameterList getParameterList( )
+	public ParameterList getParameterList()
 	// ino.end
 	// ino.method.getParameterList.23554.body
 	{
 		// otth: gibt die Parameterliste zurueck
 		return this.parameterlist;
 	}
+
 	// ino.end
 
 	// ino.method.getParameterCount.23557.defdescription type=javadoc
 	/**
 	 * Author: Jrg Buerle<br/>
+	 * 
 	 * @return Die Anzahl der Methoden-Paramater
 	 */
 	// ino.end
@@ -272,11 +269,12 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	// ino.end
 	// ino.method.getParameterCount.23557.body
 	{
-        if(this.getParameterList() == null)
+		if (this.getParameterList() == null)
 			return 0;
 		else
 			return this.getParameterList().getParameterCount();
 	}
+
 	// ino.end
 
 	// ino.method.get_ExceptionList.23560.definition
@@ -287,6 +285,7 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 		// otth: gibt die Exceptionliste zurueck
 		return this.exceptionlist;
 	}
+
 	// ino.end
 
 	// ino.method.getOverloadedID.23563.definition
@@ -294,8 +293,9 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	// ino.end
 	// ino.method.getOverloadedID.23563.body
 	{
-        return(overloadedID);
+		return (overloadedID);
 	}
+
 	// ino.end
 
 	// ino.method.setOverloadedID.23566.definition
@@ -303,22 +303,20 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	// ino.end
 	// ino.method.setOverloadedID.23566.body
 	{
-        this.overloadedID=overloadedID;
+		this.overloadedID = overloadedID;
 	}
+
 	// ino.end
 
-
-    
-    
-    
 	// ino.method.get_Method_Name.23575.definition
 	public String get_Method_Name()
 	// ino.end
 	// ino.method.get_Method_Name.23575.body
 	{
-        DeclId hilf=declid.elementAt(0);
+		DeclId hilf = declid.elementAt(0);
 		return hilf.get_Name();
 	}
+
 	// ino.end
 
 	// ino.method.get_Type_Paralist.23578.definition
@@ -328,10 +326,9 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	{
 		return types_in_parameterlist;
 	}
+
 	// ino.end
 
-    
-
 	// ino.method.getLineNumber.23584.definition
 	public int getLineNumber()
 	// ino.end
@@ -339,6 +336,7 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	{
 		return m_LineNumber;
 	}
+
 	// ino.end
 
 	// ino.method.setLineNumber.23587.definition
@@ -348,6 +346,7 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	{
 		m_LineNumber = lineNumber;
 	}
+
 	// ino.end
 
 	// ino.method.getOffset.23590.defdescription type=line
@@ -360,6 +359,7 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	{
 		return m_Offset;
 	}
+
 	// ino.end
 
 	// ino.method.getVariableLength.23593.definition
@@ -369,6 +369,7 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	{
 		return get_Method_Name().length();
 	}
+
 	// ino.end
 
 	// ino.method.setOffset.23596.defdescription type=line
@@ -381,12 +382,14 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	{
 		m_Offset = Offset;
 	}
-    // ino.end
 
+	// ino.end
 
 	// ino.method.getTypeLineNumber.23602.defdescription type=javadoc
 	/**
-     * <br>Author: Jrg Buerle
+	 * <br>
+	 * Author: Jrg Buerle
+	 * 
 	 * @return
 	 */
 	// ino.end
@@ -397,11 +400,14 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	{
 		return this.getLineNumber();
 	}
+
 	// ino.end
 
 	// ino.method.toString.23605.defdescription type=javadoc
 	/**
-     * <br/>Author: Martin Pl�micke
+	 * <br/>
+	 * Author: Martin Pl�micke
+	 * 
 	 * @return
 	 */
 	// ino.end
@@ -410,14 +416,16 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	// ino.end
 	// ino.method.toString.23605.body
 	{
-        return this.getType() + " "+ this.get_Name() +( (block!=null)?block.toString():"");
+		return this.getType() + " " + this.get_Name()
+				+ ((block != null) ? block.toString() : "");
 	}
+
 	// ino.end
 
 	// ino.method.setAbstract.23608.defdescription type=javadoc
 	/**
-     * Legt fuer die ByteCodeGen fest, ob Bytecode
+	 * Legt fuer die ByteCodeGen fest, ob Bytecode innerhalb der Methode
-     * innerhalb der Methode generiert wird.
+	 * generiert wird.
 	 */
 	// ino.end
 	// ino.method.setAbstract.23608.definition
@@ -427,12 +435,12 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	{
 		isAbstract = b;
 	}
+
 	// ino.end
 
 	// ino.method.isAbstract.23611.defdescription type=javadoc
 	/**
-     * Gibt zurueck, ob ByteCode innerhabl der Methode
+	 * Gibt zurueck, ob ByteCode innerhabl der Methode generiert wird.
-     * generiert wird.
 	 */
 	// ino.end
 	// ino.method.isAbstract.23611.definition
@@ -444,93 +452,92 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	}
 
 	@Override
-    public void wandleRefTypeAttributes2GenericAttributes(Menge<Type> classParalist)
+	public void wandleRefTypeAttributes2GenericAttributes(
-    {
+			Menge<Type> classParalist) {
 		/*
-    	Menge<Type> paralist = new Menge<Type>();//Mit den Generischen Typen der Methode
+		 * Menge<Type> paralist = new Menge<Type>();//Mit den Generischen Typen
-    	paralist.addAll(classParalist);
+		 * der Methode paralist.addAll(classParalist);
-    	paralist.addAll(this.genericMethodParameters);
+		 * paralist.addAll(this.genericMethodParameters);
-    	
+		 * 
-        // Zuerst Returntype untersuchen
+		 * // Zuerst Returntype untersuchen Type returnType=getType(); Type
-        Type returnType=getType();
+		 * pendantReturnType = null; if(returnType instanceof
-        Type pendantReturnType = null;
+		 * RefType)pendantReturnType =
-        if(returnType instanceof RefType)pendantReturnType = ((RefType)returnType).findGenericType(paralist, new Menge<GenericTypeVar>());
+		 * ((RefType)returnType).findGenericType(paralist, new
-        //GenericTypeVar pendantReturnType=ClassHelper.findGenericType(returnType, paralist,genericMethodParameters);
+		 * Menge<GenericTypeVar>()); //GenericTypeVar
-        if(pendantReturnType!=null){    //Wenn generisch, dann modifizieren
+		 * pendantReturnType=ClassHelper.findGenericType(returnType,
-            setReturnType(pendantReturnType);
+		 * paralist,genericMethodParameters); if(pendantReturnType!=null){
-        }                                       
+		 * //Wenn generisch, dann modifizieren setReturnType(pendantReturnType);
-        
+		 * }
-        // Dann parameterlist untersuchen
+		 * 
-        for(int par=0;par<getParameterCount();par++){
+		 * // Dann parameterlist untersuchen for(int
-            FormalParameter fp=parameterlist.formalparameter.get(par);
+		 * par=0;par<getParameterCount();par++){ FormalParameter
-            Type fpType=fp.getType();
+		 * fp=parameterlist.formalparameter.get(par); Type fpType=fp.getType();
-            // Nur wenn es sich um ein RefType-Field handelt
+		 * // Nur wenn es sich um ein RefType-Field handelt Type pendantPara =
-            Type pendantPara = null;
+		 * null; if(fpType instanceof RefType)pendantPara =
-            if(fpType instanceof RefType)pendantPara = ((RefType)fpType).findGenericType(paralist, new Menge<GenericTypeVar>());
+		 * ((RefType)fpType).findGenericType(paralist, new
-            //GenericTypeVar pendantPara=ClassHelper.findGenericType(fpType,paralist,genericMethodParameters);
+		 * Menge<GenericTypeVar>()); //GenericTypeVar
-            if(pendantPara!=null){  //Wenn generisch, dann modifizieren
+		 * pendantPara=ClassHelper.findGenericType
-                fp.setType(pendantPara);
+		 * (fpType,paralist,genericMethodParameters); if(pendantPara!=null){
-            }                       
+		 * //Wenn generisch, dann modifizieren fp.setType(pendantPara); } }
-        }
+		 * 
-        
+		 * // Zuletzt alle Lokalen Variablendeklarationen durchgehen
-        // Zuletzt alle Lokalen Variablendeklarationen durchgehen
+		 * if(block!=null){
-        if(block!=null){
+		 * block.wandleRefTypeAttributes2GenericAttributes(paralist
-            block.wandleRefTypeAttributes2GenericAttributes(paralist,genericMethodParameters);
+		 * ,genericMethodParameters); }
-        }
 		 */
 	}
 
-    public void set_Method_Name(String string)
+	public void set_Method_Name(String string) {
-    {
+		if (declid.size() == 0)
-    	if(declid.size()==0)declid.add(0, new DeclId(string));
+			declid.add(0, new DeclId(string));
-        declid.set(0,new DeclId(string));
+		declid.set(0, new DeclId(string));
 	}
 
-   
-    
 	public ConstraintsSet TYPE(TypeAssumptions ass) {
 		ConstraintsSet ret = new ConstraintsSet();
 		TypeAssumptions localAss = new TypeAssumptions();
-		localAss.add(ass); //Die globalen Assumptions anhängen
+		localAss.add(ass); // Die globalen Assumptions anhängen
-		//Generische Parameterdeklarationen den Assumptions anfügen:
+		// Generische Parameterdeklarationen den Assumptions anfügen:
-		for(GenericTypeVar gtv : this.getGenericParameter()){
+		for (GenericTypeVar gtv : this.getGenericParameter()) {
 			localAss.add(gtv.createAssumptions());
 		}
-		for(GenericTypeVar gtv : this.getGenericParameter()){
+		for (GenericTypeVar gtv : this.getGenericParameter()) {
 			ret.add(gtv.TYPE(localAss));
 		}
 
-		//TypeCheck, falls es sich um einen RefType handelt:
+		// TypeCheck, falls es sich um einen RefType handelt:
 		this.returntype = this.returntype.checkTYPE(localAss, this);
 		/*
-		if(this.returntype!=null && (this.returntype instanceof RefType)&&
+		 * if(this.returntype!=null && (this.returntype instanceof RefType)&&
-				!(this.returntype instanceof mycompiler.mytype.Void)){//Sonderfall der Methode: Ihr Typ darf Void definiert werden.
+		 * !(this.returntype instanceof mycompiler.mytype.Void)){//Sonderfall
-			Type replaceType = null;
+		 * der Methode: Ihr Typ darf Void definiert werden. Type replaceType =
-			replaceType = ass.getTypeFor((RefType)this.returntype);
+		 * null; replaceType = ass.getTypeFor((RefType)this.returntype);
-			if(replaceType == null)throw new TypeinferenceException("Der Typ "+this.getType().getName()+" ist nicht korrekt",this);
+		 * if(replaceType == null)throw new
-			this.returntype = replaceType;
+		 * TypeinferenceException("Der Typ "+this
-		}
+		 * .getType().getName()+" ist nicht korrekt",this); this.returntype =
+		 * replaceType; }
 		 */
-		//Die Parameter zu den Assumptions hinzufügen:
+		// Die Parameter zu den Assumptions hinzufügen:
-		if(this.parameterlist!=null)for(FormalParameter param : this.parameterlist){
+		if (this.parameterlist != null)
+			for (FormalParameter param : this.parameterlist) {
 
 				param.setType(param.getType().checkTYPE(localAss, this));
 				/*
-			if(param.getType() instanceof RefType)
+				 * if(param.getType() instanceof RefType) { Type replaceType =
-			{
+				 * null; replaceType = ass.getTypeFor((RefType)param.getType());
-				Type replaceType = null;
+				 * if(replaceType == null) throw new
-				replaceType = ass.getTypeFor((RefType)param.getType());
+				 * TypeinferenceException("Der Typ "
-				if(replaceType == null)
+				 * +param.getType().getName()+" ist nicht korrekt",param);
-					throw new TypeinferenceException("Der Typ "+param.getType().getName()+" ist nicht korrekt",param);
+				 * param.setType(replaceType); }
-				param.setType(replaceType);
-			}
 				 */
 
 				localAss.addAssumption(new ParameterAssumption(param));
 			}
 		ret.add(this.block.TYPEStmt(localAss));
-		//eine Verknüpfung mit der Type Assumption aus dem Assumption Set und dem ermittelten Typ der Methode:
+		// eine Verknüpfung mit der Type Assumption aus dem Assumption Set
-		ret.add(new SingleConstraint(this.block.getType().TYPE(localAss, this), this.returntype.TYPE(localAss, this)));
+		// und dem ermittelten Typ der Methode:
+		ret.add(new SingleConstraint(this.block.getType().TYPE(localAss, this),
+				this.returntype.TYPE(localAss, this)));
 		return ret;
 	}
 
@@ -538,15 +545,22 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	 * @author Andreas Stadelmeier, a10023
 	 * @return die TypInformationen der Statements dieser Methode.
 	 */
-	public String getTypeInformation(){
+	public String getTypeInformation() {
-		if(this.parameterlist!=null)return "Methode "+this.get_Name()+ " Parameter: "+this.parameterlist.getTypeInformation()+", Block: "+this.block.getTypeInformation();
+		if (this.parameterlist != null)
-		return "Methode "+this.get_Name()+" : "+this.getType()+", Block: "+this.block.getTypeInformation();
+			return "Methode " + this.get_Name() + " Parameter: "
+					+ this.parameterlist.getTypeInformation() + ", Block: "
+					+ this.block.getTypeInformation();
+		return "Methode " + this.get_Name() + " : " + this.getType()
+				+ ", Block: " + this.block.getTypeInformation();
 	}
 
 	@Override
 	public JavaCodeResult printJavaCode(ResultSet resultSet) {
 		JavaCodeResult ret = new JavaCodeResult();
-		ret.attach(this.getType().printJavaCode(resultSet)).attach(" ").attach(this.get_Method_Name()).attach("(").attach(this.getParameterList().printJavaCode(resultSet)).attach(")\n"); 
+		ret.attach(this.getType().printJavaCode(resultSet)).attach(" ")
+				.attach(this.get_Method_Name()).attach("(")
+				.attach(this.getParameterList().printJavaCode(resultSet))
+				.attach(")\n");
 		ret.attach(this.block.printJavaCode(resultSet));
 
 		return ret;
@@ -557,107 +571,110 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	 */
 	@Override
 	public TypeAssumptions createTypeAssumptions(Class classmember) {
-		Class parentClass = classmember;//this.getParentClass();
+		Class parentClass = classmember;// this.getParentClass();
 		TypeAssumptions ret = new TypeAssumptions();
 		ret.addAssumption(new MethodAssumption(this, parentClass));
 		return ret;
 		/*
-		TypeAssumptions assumptions = new TypeAssumptions();
+		 * TypeAssumptions assumptions = new TypeAssumptions(); this.assumedType
-		this.assumedType = null;
+		 * = null; //if((this.get_Method_Name().equals(classmember.getName()) ||
-		//if((this.get_Method_Name().equals(classmember.getName()) || this.get_Method_Name().equals("<init>")) && ((this.getType().equals(new mycompiler.mytype.Void(0))) || this.getType() instanceof TypePlaceholder)){
+		 * this.get_Method_Name().equals("<init>")) &&
-		if((this.get_Method_Name().equals(classmember.getName()) || this.get_Method_Name().equals("<init>"))) {
+		 * ((this.getType().equals(new mycompiler.mytype.Void(0))) ||
-			this.set_Method_Name("<init>");
+		 * this.getType() instanceof TypePlaceholder)){
-			this.assumedType = new RefType(classmember.getName(),0);
+		 * if((this.get_Method_Name().equals(classmember.getName()) ||
-			this.setReturnType(this.assumedType);
+		 * this.get_Method_Name().equals("<init>"))) {
-			this.assumedType = new RefType("void",0);
+		 * this.set_Method_Name("<init>"); this.assumedType = new
-			//Return constructorReturnStatement = new Return(0,0);
+		 * RefType(classmember.getName(),0);
-			//constructorReturnStatement.retexpr = 
+		 * this.setReturnType(this.assumedType); this.assumedType = new
-			//this.block.statements.add(constructorReturnStatement);
+		 * RefType("void",0); //Return constructorReturnStatement = new
-		}
+		 * Return(0,0); //constructorReturnStatement.retexpr =
-		//hoth: 06.04.2006
+		 * //this.block.statements.add(constructorReturnStatement); } //hoth:
-		//durchlaufe Block und suche nach Objektvariablen fuer Offset-Markierung
+		 * 06.04.2006 //durchlaufe Block und suche nach Objektvariablen fuer
-		Iterator<CTypeAssumption> fieldVarIterator = assumptions.iterator();
+		 * Offset-Markierung Iterator<CTypeAssumption> fieldVarIterator =
-		while (fieldVarIterator.hasNext()) 
+		 * assumptions.iterator(); while (fieldVarIterator.hasNext()) { //Wenn
-		{
+		 * ObjektVariable CTypeAssumption dieAssum = fieldVarIterator.next();
-		//Wenn ObjektVariable
+		 * if(dieAssum instanceof CInstVarTypeAssumption) {
-		CTypeAssumption dieAssum = fieldVarIterator.next();
+		 * Class.isFirstLocalVarDecl=false; if(this.get_Block() != null)
-		if(dieAssum instanceof CInstVarTypeAssumption)
+		 * this.get_Block
-		{
+		 * ().addOffsetsToAssumption(dieAssum,dieAssum.getIdentifier(),true); }
-			Class.isFirstLocalVarDecl=false; 
+		 * }
-			if(this.get_Block() != null)
+		 * 
-				this.get_Block().addOffsetsToAssumption(dieAssum,dieAssum.getIdentifier(),true);  
+		 * //methodList.addElement(method);
-		}
+		 * 
-		}
+		 * //F�r V_fields_methods: CMethodTypeAssumption methodAssum
-		
+		 * = new CMethodTypeAssumption(classmember.getType(),
-		//methodList.addElement(method);
+		 * this.get_Method_Name(), this.getType(),
-		
+		 * this.getParameterCount(),this.getLineNumber(),this.getOffset(),new
-		//F�r V_fields_methods:
+		 * Menge<Integer>(),this.getGenericMethodParameters()); // Typannahme
-		CMethodTypeAssumption methodAssum = new CMethodTypeAssumption(classmember.getType(), this.get_Method_Name(), this.getType(), this.getParameterCount(),this.getLineNumber(),this.getOffset(),new Menge<Integer>(),this.getGenericMethodParameters());  // Typannahme bauen...
+		 * bauen...
-		
+		 * 
-		
+		 * 
-		//Methode in V_Fields_methods ablegen
+		 * //Methode in V_Fields_methods ablegen //Dabei wird die
-		//Dabei wird die OverloadedMethodID ermittelt !!
+		 * OverloadedMethodID ermittelt !! //=> Method setzenuct
-		//=> Method setzenuct
+		 * 
-		
+		 * 
-		
+		 * assumptions.add(methodAssum);
-		assumptions.add(methodAssum);               
+		 * this.setOverloadedID(methodAssum.getHashSetKey
-		this.setOverloadedID(methodAssum.getHashSetKey().getOverloadedMethodID());                
+		 * ().getOverloadedMethodID());
-		
+		 * 
-		
+		 * 
-		//F�r die V_i:
+		 * //F�r die V_i: CTypeAssumptionSet localAssum = new
-		CTypeAssumptionSet localAssum = new CTypeAssumptionSet();
+		 * CTypeAssumptionSet();
-		
+		 * 
-		//Bauen...
+		 * //Bauen... ParameterList parameterList = this.getParameterList();
-		ParameterList parameterList = this.getParameterList();
+		 * if(parameterList!=null){ for(int i=0;
-		if(parameterList!=null){
+		 * i<parameterList.sc_get_Formalparalist().size(); i++){ FormalParameter
-		for(int i=0; i<parameterList.sc_get_Formalparalist().size(); i++){
+		 * para = parameterList.sc_get_Formalparalist().elementAt(i); //
-		FormalParameter para = parameterList.sc_get_Formalparalist().elementAt(i);
+		 * F�r V_fields_methods: CParaTypeAssumption paraAssum = new
-		// F�r V_fields_methods:
+		 * CParaTypeAssumption(classmember.getName(), this.get_Method_Name(),
-		CParaTypeAssumption paraAssum = new CParaTypeAssumption(classmember.getName(), this.get_Method_Name(), this.getParameterCount(), this.getOverloadedID(),para.get_Name(), para.getType(), para.getLineNumber(),para.getOffset(),new Menge<Integer>());
+		 * this.getParameterCount(), this.getOverloadedID(),para.get_Name(),
-		//fuege Offsets fuer Parameter hinzu, hoth: 06.04.2006
+		 * para.getType(), para.getLineNumber(),para.getOffset(),new
-		Class.isFirstLocalVarDecl=false;
+		 * Menge<Integer>()); //fuege Offsets fuer Parameter hinzu, hoth:
-	
+		 * 06.04.2006 Class.isFirstLocalVarDecl=false;
-			if(this.get_Block() != null)
+		 * 
-				this.get_Block().addOffsetsToAssumption(paraAssum,paraAssum.getIdentifier(),true);
+		 * if(this.get_Block() != null)
-	
+		 * this.get_Block().addOffsetsToAssumption(paraAssum
-			methodAssum.addParaAssumption(paraAssum);
+		 * ,paraAssum.getIdentifier(),true);
-	
+		 * 
-			// F�r die V_i:
+		 * methodAssum.addParaAssumption(paraAssum);
-			CLocalVarTypeAssumption varAssum = new CLocalVarTypeAssumption(classmember.getName(), this.get_Method_Name(), this.getParameterCount(), this.getOverloadedID(),"1", para.get_Name(),para.getType(), para.getLineNumber(),para.getOffset(),new Menge<Integer>());
+		 * 
-			localAssum.addElement(varAssum);
+		 * // F�r die V_i: CLocalVarTypeAssumption varAssum = new
-			//rememberLocals.addElement(varAssum);
+		 * CLocalVarTypeAssumption(classmember.getName(),
-		}
+		 * this.get_Method_Name(), this.getParameterCount(),
-		}               
+		 * this.getOverloadedID(),"1", para.get_Name(),para.getType(),
-		//...und hinzuf�gen:
+		 * para.getLineNumber(),para.getOffset(),new Menge<Integer>());
-	
+		 * localAssum.addElement(varAssum);
-		assumptions.add(localAssum);//Assumptions für lokale Variablen den Assumptions hinzufügen
+		 * //rememberLocals.addElement(varAssum); } } //...und
-		
+		 * hinzuf�gen:
-		//Hier wird der Typ der als Assumption eingetragen wird in die Variable assumedType dieser Klasse geschrieben:
+		 * 
-		if(this.assumedType == null) // Falls der Typ nicht schon gesetzt ist. Das ist der Fall, falls die Methode ein Konstruktor ist
+		 * assumptions.add(localAssum);//Assumptions für lokale Variablen den
-			this.assumedType = methodAssum.getAssumedType();
+		 * Assumptions hinzufügen
-		
+		 * 
-		return assumptions;
+		 * //Hier wird der Typ der als Assumption eingetragen wird in die
+		 * Variable assumedType dieser Klasse geschrieben: if(this.assumedType
+		 * == null) // Falls der Typ nicht schon gesetzt ist. Das ist der Fall,
+		 * falls die Methode ein Konstruktor ist this.assumedType =
+		 * methodAssum.getAssumedType();
+		 * 
+		 * return assumptions;
 		 */
 	}
 
-	
 	@Override
-	public void parserPostProcessing(SyntaxTreeNode parent){
+	public void parserPostProcessing(SyntaxTreeNode parent) {
-		if(this.getType()==null)this.setType(TypePlaceholder.fresh(this));
+		if (this.getType() == null)
-		//Bei dem Elterntyp der Methode darf es sich nur um eine Klasse handeln, daher Cast ohne Prüfung:
+			this.setType(TypePlaceholder.fresh(this));
-		//Class parentClass = (Class)parent;
+		// Bei dem Elterntyp der Methode darf es sich nur um eine Klasse
-		if(this.returntype == null)this.returntype = TypePlaceholder.fresh(this);
+		// handeln, daher Cast ohne Prüfung:
+		// Class parentClass = (Class)parent;
+		if (this.returntype == null)
+			this.returntype = TypePlaceholder.fresh(this);
 		super.parserPostProcessing(parent);
 		/*
-		this.returntype.parserPostProcessing(this);
+		 * this.returntype.parserPostProcessing(this); if(this.parameterlist !=
-		if(this.parameterlist != null){
+		 * null){ for(FormalParameter fp : this.parameterlist){
-			for(FormalParameter fp : this.parameterlist){
+		 * fp.parserPostProcessing(this); } } for(GenericTypeVar gtv :
-				fp.parserPostProcessing(this);
+		 * this.getGenericParameter()){ gtv.parserPostProcessing(this); }
-			}
-		}
-		for(GenericTypeVar gtv : this.getGenericParameter()){
-			gtv.parserPostProcessing(this);
-		}
 		 */
 	}
 
@@ -672,45 +689,68 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	}
 
 	@Override
-	public void setType(Type t){
+	public void setType(Type t) {
 		// Methode und Block teilen sich einen ReturnType:
-		//this.block.setType(t);
+		// this.block.setType(t);
 		this.returntype = t;
-		this.returntype.parent = this; //TODO: Dieser Hack sollte nicht nötig sein. (Parser ändern)
+		this.returntype.parent = this; // TODO: Dieser Hack sollte nicht
+										// nötig sein. (Parser ändern)
 	}
 
 	/**
 	 * Der Typ einer Methode ist ihr Returntype
 	 */
 	@Override
-	public Type getType(){
+	public Type getType() {
-		//Methode und Block teilen sich einen ReturnType:
+		// Methode und Block teilen sich einen ReturnType:
 		return this.returntype;
 	}
 
-	public static Method createEmptyMethod(String withSignature, Class parent){
+	public static Method createEmptyMethod(String withSignature, Class parent) {
 		Method ret = new Method(0);
 		DeclId DImethod = new DeclId();
 		DImethod.set_Name(withSignature);
 		ret.set_DeclId(DImethod);
 		Block tempBlock = new Block();
-		//tempBlock.setType(new RefType(parent.getName(),0));
+		// tempBlock.setType(new RefType(parent.getName(),0));
 		ret.set_Block(tempBlock);
 		ret.parserPostProcessing(parent);
 		return ret;
 	}
 
 	@Override
-	public boolean equals(Object obj){
+	public boolean equals(Object obj) {
-		if(!(obj instanceof Method))return false;
+		if (!(obj instanceof Method))
+			return false;
 		Method equals = (Method) obj;
-		if((this.returntype!=null && equals.returntype==null))return false;
+		if ((this.returntype != null && equals.returntype == null))
-		if((this.returntype==null && equals.returntype!=null))return false;
+			return false;
-		if(this.returntype!=null && equals.returntype!=null)if(!this.returntype.equals(equals.returntype))return false;
+		if ((this.returntype == null && equals.returntype != null))
-		if(!this.parameterlist.equals(equals.parameterlist))return false;
+			return false;
+		if (this.returntype != null && equals.returntype != null)
+			if (!this.returntype.equals(equals.returntype))
+				return false;
+		if (!this.parameterlist.equals(equals.parameterlist))
+			return false;
 		return super.equals(obj);
 	}
 
+	@Override
+	public void genByteCode(ClassGen cg) {
+		/*ConstantPoolGen _cp = cg.getConstantPool();
+		 * InstructionFactory _factory = new InstructionFactory(cg, _cp);
+		 * InstructionList il = new InstructionList();
+		 * Class parentClass = this.getParentClass();
+		*/
+		
+		//oben steht MethodGen method als Variable (Z. 71)
+		
+		// Über Statements iterieren um Block abzurufen
+		for (Statement statements : block.get_Statement()) {
+			statements.genByteCode(cg);
+		}
+		
+	}
 
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/SyntaxTreeNode.java

@@ -1,7 +1,8 @@
 package de.dhbwstuttgart.syntaxtree;
 
-import de.dhbwstuttgart.typeinference.Menge;
+import org.apache.bcel.generic.ClassGen;
 
+import de.dhbwstuttgart.typeinference.Menge;
 import de.dhbwstuttgart.core.IItemWithOffset;
 import de.dhbwstuttgart.syntaxtree.type.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.type.Type;
@@ -126,4 +127,6 @@ public abstract class SyntaxTreeNode implements IItemWithOffset{
 		return this.getParent().getGTVDeclarationContext();
 	}
 
+	
+
 }

src/de/dhbwstuttgart/syntaxtree/statement/Assign.java

@@ -5,10 +5,11 @@ package de.dhbwstuttgart.syntaxtree.statement;
 import java.util.Enumeration;
 import java.util.Hashtable;
 import java.util.Iterator;
+
+import org.apache.bcel.generic.ClassGen;
+
 import de.dhbwstuttgart.typeinference.Menge;
-
 import de.dhbwstuttgart.logger.Logger;
-
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.myexception.SCExcept;
@@ -166,5 +167,15 @@ public class Assign extends Expr
 		return ret;
 	}
 
+
+
+
+
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
+
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/Binary.java

@@ -5,10 +5,11 @@ package de.dhbwstuttgart.syntaxtree.statement;
 import java.util.Enumeration;
 import java.util.HashMap;
 import java.util.Hashtable;
+
+import org.apache.bcel.generic.ClassGen;
+
 import de.dhbwstuttgart.typeinference.Menge;
-
 import de.dhbwstuttgart.logger.Logger;
-
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.myexception.SCExcept;
@@ -212,5 +213,13 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
 	}
 
 
+
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
+    
+    
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/Block.java

@@ -5,8 +5,16 @@ package de.dhbwstuttgart.syntaxtree.statement;
 import java.util.Enumeration;
 import java.util.Hashtable;
 import java.util.Iterator;
-import de.dhbwstuttgart.typeinference.Menge;
 
+import org.apache.bcel.Constants;
+import org.apache.bcel.generic.ClassGen;
+import org.apache.bcel.generic.ConstantPoolGen;
+import org.apache.bcel.generic.InstructionFactory;
+import org.apache.bcel.generic.InstructionHandle;
+import org.apache.bcel.generic.InstructionList;
+import org.apache.bcel.generic.MethodGen;
+
+import de.dhbwstuttgart.typeinference.Menge;
 import de.dhbwstuttgart.logger.Logger;
 import de.dhbwstuttgart.logger.Section;
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
@@ -14,6 +22,7 @@ import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.myexception.SCExcept;
 import de.dhbwstuttgart.myexception.SCStatementException;
 import de.dhbwstuttgart.syntaxtree.Class;
+import de.dhbwstuttgart.syntaxtree.Field;
 import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
 import de.dhbwstuttgart.syntaxtree.type.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.type.Type;
@@ -37,6 +46,9 @@ public class Block extends Statement
 // ino.end
 // ino.class.Block.25037.body
 {
+	private InstructionFactory _factory;
+    private ConstantPoolGen    _cp;
+    private ClassGen           _cg;
     
     // ino.method.Block.25041.definition 
     public Block()
@@ -81,6 +93,7 @@ public class Block extends Statement
     
 
     
+    
     // ino.method.set_Statement.25068.definition 
     public void set_Statement(Statement s)
     // ino.end
@@ -224,6 +237,7 @@ public class Block extends Statement
 			ret.attach(stmt.printJavaCode(resultSet));
 			ret.attach((stmt instanceof ExprStmt ? ";" : "") + "\n");
 		}
+		
 		return ret.attach("}");
 
 	}
@@ -241,5 +255,24 @@ public class Block extends Statement
 	public String getDescription(){
 		return "Block";
 	}
+	
+	@Override
+    public void genByteCode(ClassGen cg) {
+		//ConstantPoolGen _cp = cg.getConstantPool();
+		InstructionFactory _factory = new InstructionFactory(cg, _cp);
+		InstructionList il = new InstructionList();
+		
+		//Frage: Wenn Block von Statements erbt, und Block selbst keinen BCEL Code besitzt, ist das hier dann nicht eine Sackgasse?
+	    
+		//Instructionhandle dynamisch
+		InstructionHandle ih_0 = il.append(_factory.createLoad(org.apache.bcel.generic.Type.OBJECT, 0)); 
+	    il.append(_factory.createInvoke(this.getParentClass().superclassid.toString(), "<init>", org.apache.bcel.generic.Type.VOID, org.apache.bcel.generic.Type.NO_ARGS, Constants.INVOKESPECIAL));
+	    InstructionHandle ih_4 = il.append(_factory.createReturn(org.apache.bcel.generic.Type.VOID)); 
+		
+		il.dispose();
+			
+	}
 }
 // ino.end
+
+

src/de/dhbwstuttgart/syntaxtree/statement/BoolLiteral.java

@@ -3,8 +3,10 @@ package de.dhbwstuttgart.syntaxtree.statement;
 // ino.end
 // ino.module.BoolLiteral.8626.import 
 import java.util.Hashtable;
-import de.dhbwstuttgart.typeinference.Menge;
 
+import org.apache.bcel.generic.ClassGen;
+
+import de.dhbwstuttgart.typeinference.Menge;
 import de.dhbwstuttgart.logger.Logger;
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
@@ -28,6 +30,14 @@ public class BoolLiteral extends Literal
 // ino.end
 // ino.class.BoolLiteral.25089.body
 {
+    @Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
+
+
+
 	// ino.attribute.Bool.25093.declaration 
     private boolean Bool;
     // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/CastExpr.java

@@ -4,8 +4,10 @@ package de.dhbwstuttgart.syntaxtree.statement;
 // ino.module.CastExpr.8627.import 
 import java.util.Hashtable;
 import java.util.Iterator;
-import de.dhbwstuttgart.typeinference.Menge;
 
+import org.apache.bcel.generic.ClassGen;
+
+import de.dhbwstuttgart.typeinference.Menge;
 import de.dhbwstuttgart.logger.Logger;
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
@@ -118,5 +120,13 @@ public class CastExpr extends UnaryExpr
 	}
 
 
+
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
+
+    
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/CharLiteral.java

@@ -3,6 +3,9 @@ package de.dhbwstuttgart.syntaxtree.statement;
 // ino.end
 // ino.module.CharLiteral.8628.import 
 import java.util.Hashtable;
+
+import org.apache.bcel.generic.ClassGen;
+
 import de.dhbwstuttgart.typeinference.Menge;
 import de.dhbwstuttgart.logger.Logger;
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
@@ -107,5 +110,12 @@ public class CharLiteral extends Literal
 			Menge<Type> paralist,
 			Menge<GenericTypeVar> genericMethodParameters) {
 	}
+
+
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/DoubleLiteral.java

@@ -3,11 +3,11 @@ package de.dhbwstuttgart.syntaxtree.statement;
 // ino.end
 // ino.module.IntLiteral.8635.import 
 import java.util.Hashtable;
+
+import org.apache.bcel.generic.ClassGen;
+
 import de.dhbwstuttgart.typeinference.Menge;
-
-
 import de.dhbwstuttgart.logger.Logger;
-
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.syntaxtree.Class;
@@ -130,5 +130,11 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
 		Menge<SyntaxTreeNode> ret = new Menge<SyntaxTreeNode>();
 		return ret;
 	}
+
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/EmptyStmt.java

@@ -3,10 +3,11 @@ package de.dhbwstuttgart.syntaxtree.statement;
 // ino.end
 // ino.module.EmptyStmt.8629.import 
 import java.util.Hashtable;
+
+import org.apache.bcel.generic.ClassGen;
+
 import de.dhbwstuttgart.typeinference.Menge;
-
 import de.dhbwstuttgart.logger.Logger;
-
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.syntaxtree.Class;
@@ -85,5 +86,12 @@ public class EmptyStmt extends Statement
 		return new Menge<SyntaxTreeNode>();
 	}
 
+
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
+
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/FloatLiteral.java

@@ -3,10 +3,11 @@ package de.dhbwstuttgart.syntaxtree.statement;
 // ino.end
 // ino.module.IntLiteral.8635.import 
 import java.util.Hashtable;
+
+import org.apache.bcel.generic.ClassGen;
+
 import de.dhbwstuttgart.typeinference.Menge;
-
 import de.dhbwstuttgart.logger.Logger;
-
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.syntaxtree.Class;
@@ -126,5 +127,11 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
 		Menge<SyntaxTreeNode> ret = new Menge<SyntaxTreeNode>();
 		return ret;
 	}
+
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/ForStmt.java

@@ -3,10 +3,11 @@ package de.dhbwstuttgart.syntaxtree.statement;
 import java.util.Enumeration;
 import java.util.Hashtable;
 import java.util.Iterator;
+
+import org.apache.bcel.generic.ClassGen;
+
 import de.dhbwstuttgart.typeinference.Menge;
-
 import de.dhbwstuttgart.logger.Logger;
-
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.myexception.SCExcept;
@@ -115,4 +116,10 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
 		//throw new NotImplementedException();
 		return ret;
 	}
+
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
 }

src/de/dhbwstuttgart/syntaxtree/statement/IfStmt.java

@@ -5,10 +5,11 @@ package de.dhbwstuttgart.syntaxtree.statement;
 import java.util.Enumeration;
 import java.util.Hashtable;
 import java.util.Iterator;
+
+import org.apache.bcel.generic.ClassGen;
+
 import de.dhbwstuttgart.typeinference.Menge;
-
 import de.dhbwstuttgart.logger.Logger;
-
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.myexception.SCExcept;
@@ -160,5 +161,13 @@ public class IfStmt extends Statement
 		if(this.then_block!=null)ret.add(this.then_block);
 		return ret;
 	}
+
+
+
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/InstVar.java

@@ -5,10 +5,11 @@ package de.dhbwstuttgart.syntaxtree.statement;
 import java.util.Enumeration;
 import java.util.Hashtable;
 import java.util.Iterator;
+
+import org.apache.bcel.generic.ClassGen;
+
 import de.dhbwstuttgart.typeinference.Menge;
-
 import de.dhbwstuttgart.logger.Logger;
-
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.syntaxtree.Class;
@@ -214,5 +215,11 @@ public class InstVar extends Expr
 		ret.add(this.expr);
 		return ret;
 	}
+
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/InstanceOf.java

@@ -4,10 +4,11 @@ package de.dhbwstuttgart.syntaxtree.statement;
 // ino.module.InstanceOf.8633.import 
 import java.util.Enumeration;
 import java.util.Hashtable;
+
+import org.apache.bcel.generic.ClassGen;
+
 import de.dhbwstuttgart.typeinference.Menge;
-
 import de.dhbwstuttgart.logger.Logger;
-
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.myexception.SCStatementException;
@@ -115,6 +116,12 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
 		return ret;
 	}
 
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
+    
     
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/IntLiteral.java

@@ -3,8 +3,10 @@ package de.dhbwstuttgart.syntaxtree.statement;
 // ino.end
 // ino.module.IntLiteral.8635.import 
 import java.util.Hashtable;
-import de.dhbwstuttgart.typeinference.Menge;
 
+import org.apache.bcel.generic.ClassGen;
+
+import de.dhbwstuttgart.typeinference.Menge;
 import de.dhbwstuttgart.logger.Logger;
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
@@ -128,5 +130,11 @@ public class IntLiteral extends Literal
 		Menge<SyntaxTreeNode> ret = new Menge<SyntaxTreeNode>();
 		return ret;
 	}
+
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/LambdaExpression.java

@@ -1,8 +1,10 @@
 package de.dhbwstuttgart.syntaxtree.statement;
 
 import java.util.Hashtable;
-import de.dhbwstuttgart.typeinference.Menge;
 
+import org.apache.bcel.generic.ClassGen;
+
+import de.dhbwstuttgart.typeinference.Menge;
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.myexception.SCStatementException;
@@ -206,4 +208,10 @@ public class LambdaExpression extends Expr{
 		return ret;
 	}
 
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
+
 }

src/de/dhbwstuttgart/syntaxtree/statement/LocalOrFieldVar.java

@@ -4,8 +4,10 @@ package de.dhbwstuttgart.syntaxtree.statement;
 // ino.module.LocalOrFieldVar.8637.import 
 import java.util.Enumeration;
 import java.util.Hashtable;
-import de.dhbwstuttgart.typeinference.Menge;
 
+import org.apache.bcel.generic.ClassGen;
+
+import de.dhbwstuttgart.typeinference.Menge;
 import de.dhbwstuttgart.logger.Logger;
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
@@ -133,5 +135,11 @@ public class LocalOrFieldVar extends Expr
 		return ret;
 	}
 
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
+
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/LocalVarDecl.java

@@ -4,10 +4,11 @@ package de.dhbwstuttgart.syntaxtree.statement;
 // ino.module.LocalVarDecl.8638.import 
 import java.util.Enumeration;
 import java.util.Hashtable;
+
+import org.apache.bcel.generic.ClassGen;
+
 import de.dhbwstuttgart.typeinference.Menge;
-
 import de.dhbwstuttgart.logger.Logger;
-
 import de.dhbwstuttgart.core.MyCompiler;
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.myexception.SCExcept;
@@ -422,5 +423,11 @@ public class LocalVarDecl extends Statement implements TypeInsertable
 			ResultSet resultSet) {
 		return new TypeInsertPoint(this, this, resultSet.getTypeEqualTo(tph),resultSet);
 	}
+
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/LongLiteral.java

@@ -3,11 +3,11 @@ package de.dhbwstuttgart.syntaxtree.statement;
 // ino.end
 // ino.module.IntLiteral.8635.import 
 import java.util.Hashtable;
+
+import org.apache.bcel.generic.ClassGen;
+
 import de.dhbwstuttgart.typeinference.Menge;
-
-
 import de.dhbwstuttgart.logger.Logger;
-
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.syntaxtree.Class;
@@ -125,5 +125,11 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
 		Menge<SyntaxTreeNode> ret = new Menge<SyntaxTreeNode>();
 		return ret;
 	}
+
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/MethodCall.java

@@ -3,8 +3,10 @@ package de.dhbwstuttgart.syntaxtree.statement;
 // ino.end
 // ino.module.MethodCall.8639.import 
 import java.util.Hashtable;
-import de.dhbwstuttgart.typeinference.Menge;
 
+import org.apache.bcel.generic.ClassGen;
+
+import de.dhbwstuttgart.typeinference.Menge;
 import de.dhbwstuttgart.logger.Logger;
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.syntaxtree.Method;
@@ -48,7 +50,6 @@ public class MethodCall extends Expr
     }
     // ino.end
 
-
     // ino.attribute.receiver.25639.declaration 
     /**
      * Diese Variable speichert die Expression, welche die Klasse von welcher die Methode aufgerufen wird darstellt.
@@ -303,5 +304,11 @@ public class MethodCall extends Expr
 		super.parserPostProcessing(parent);	
 	}
 
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
+	
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/NegativeExpr.java

@@ -4,10 +4,11 @@ package de.dhbwstuttgart.syntaxtree.statement;
 // ino.module.NegativeExpr.8640.import 
 import java.util.Hashtable;
 import java.util.Iterator;
+
+import org.apache.bcel.generic.ClassGen;
+
 import de.dhbwstuttgart.typeinference.Menge;
-
 import de.dhbwstuttgart.logger.Logger;
-
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.myexception.SCExcept;
@@ -107,5 +108,11 @@ public class NegativeExpr extends UnaryExpr
 		return ret;
 	}
 
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
+
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/NewArray.java

@@ -3,9 +3,10 @@ package de.dhbwstuttgart.syntaxtree.statement;
 // ino.end
 // ino.module.NewArray.8641.import 
 import java.util.Hashtable;
+
+import org.apache.bcel.generic.ClassGen;
+
 import de.dhbwstuttgart.typeinference.Menge;
-
-
 import de.dhbwstuttgart.logger.Logger;
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
@@ -142,5 +143,11 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
 		return ret;
 	}
 
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
+
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/NewClass.java

@@ -5,9 +5,10 @@ package de.dhbwstuttgart.syntaxtree.statement;
 import java.util.Enumeration;
 import java.util.Hashtable;
 import java.util.Iterator;
+
+import org.apache.bcel.generic.ClassGen;
+
 import de.dhbwstuttgart.typeinference.Menge;
-
-
 import de.dhbwstuttgart.logger.Logger;
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
@@ -202,6 +203,12 @@ public class NewClass extends Expr
 		return ret;
 	}
 
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
+	
 	
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/NotExpr.java

@@ -4,10 +4,11 @@ package de.dhbwstuttgart.syntaxtree.statement;
 // ino.module.NotExpr.8643.import 
 import java.util.Hashtable;
 import java.util.Iterator;
+
+import org.apache.bcel.generic.ClassGen;
+
 import de.dhbwstuttgart.typeinference.Menge;
-
 import de.dhbwstuttgart.logger.Logger;
-
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.myexception.SCStatementException;
@@ -132,5 +133,11 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
 		return ret;
 	}
 
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
+
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/Null.java

@@ -3,9 +3,10 @@ package de.dhbwstuttgart.syntaxtree.statement;
 // ino.end
 // ino.module.Null.8644.import 
 import java.util.Hashtable;
+
+import org.apache.bcel.generic.ClassGen;
+
 import de.dhbwstuttgart.typeinference.Menge;
-
-
 import de.dhbwstuttgart.logger.Logger;
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
@@ -89,5 +90,11 @@ public class Null extends Literal
 		return new Menge<SyntaxTreeNode>();
 	}
 
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
+
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/PositivExpr.java

@@ -3,9 +3,10 @@ package de.dhbwstuttgart.syntaxtree.statement;
 // ino.end
 // ino.module.PositivExpr.8645.import 
 import java.util.Hashtable;
+
+import org.apache.bcel.generic.ClassGen;
+
 import de.dhbwstuttgart.typeinference.Menge;
-
-
 import de.dhbwstuttgart.logger.Logger;
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
@@ -115,5 +116,11 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
 		return ret;
 	}
 
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
+
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/PostDecExpr.java

@@ -4,10 +4,11 @@ package de.dhbwstuttgart.syntaxtree.statement;
 // ino.module.PostDecExpr.8646.import 
 import java.util.Hashtable;
 import java.util.Iterator;
+
+import org.apache.bcel.generic.ClassGen;
+
 import de.dhbwstuttgart.typeinference.Menge;
-
 import de.dhbwstuttgart.logger.Logger;
-
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.myexception.SCExcept;
@@ -88,5 +89,11 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
 		return ret;
 	}
 
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
+
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/PostIncExpr.java

@@ -4,10 +4,11 @@ package de.dhbwstuttgart.syntaxtree.statement;
 // ino.module.PostIncExpr.8647.import 
 import java.util.Hashtable;
 import java.util.Iterator;
+
+import org.apache.bcel.generic.ClassGen;
+
 import de.dhbwstuttgart.typeinference.Menge;
-
 import de.dhbwstuttgart.logger.Logger;
-
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.myexception.SCExcept;
@@ -94,5 +95,11 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
 		return ret;
 	}
 
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
+
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/PreDecExpr.java

@@ -4,10 +4,11 @@ package de.dhbwstuttgart.syntaxtree.statement;
 // ino.module.PreDecExpr.8648.import 
 import java.util.Hashtable;
 import java.util.Iterator;
+
+import org.apache.bcel.generic.ClassGen;
+
 import de.dhbwstuttgart.typeinference.Menge;
-
 import de.dhbwstuttgart.logger.Logger;
-
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.myexception.SCExcept;
@@ -86,6 +87,11 @@ public class PreDecExpr extends UnaryExpr
 		ret.add(this.expr);
 		return ret;
 	}
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
 
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/PreIncExpr.java

@@ -4,10 +4,11 @@ package de.dhbwstuttgart.syntaxtree.statement;
 // ino.module.PreIncExpr.8649.import 
 import java.util.Hashtable;
 import java.util.Iterator;
+
+import org.apache.bcel.generic.ClassGen;
+
 import de.dhbwstuttgart.typeinference.Menge;
-
 import de.dhbwstuttgart.logger.Logger;
-
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.myexception.SCExcept;
@@ -89,5 +90,11 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) {
 		return ret;
 	}
 
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
+
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/Return.java

@@ -3,8 +3,10 @@ package de.dhbwstuttgart.syntaxtree.statement;
 // ino.end
 // ino.module.Return.8651.import 
 import java.util.Hashtable;
-import de.dhbwstuttgart.typeinference.Menge;
 
+import org.apache.bcel.generic.ClassGen;
+
+import de.dhbwstuttgart.typeinference.Menge;
 import de.dhbwstuttgart.logger.Logger;
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
@@ -126,5 +128,11 @@ public class Return extends Statement
 	public Type getReturnType(){
 		return this.getType();
 	}
+
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/Statement.java

@@ -4,8 +4,13 @@ package de.dhbwstuttgart.syntaxtree.statement;
 // ino.module.Statement.8652.import 
 import java.util.Enumeration;
 import java.util.Hashtable;
-import de.dhbwstuttgart.typeinference.Menge;
 
+import org.apache.bcel.generic.ClassGen;
+import org.apache.bcel.generic.ConstantPoolGen;
+import org.apache.bcel.generic.InstructionFactory;
+import org.apache.bcel.generic.InstructionList;
+
+import de.dhbwstuttgart.typeinference.Menge;
 import de.dhbwstuttgart.core.IItemWithOffset;
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
@@ -122,5 +127,12 @@ public abstract class Statement extends SyntaxTreeNode implements IItemWithOffse
 	public Type getReturnType(){
 		return new de.dhbwstuttgart.syntaxtree.type.Void(this,-1);
 	}
+	
+
+	public abstract void genByteCode(ClassGen _cg);
+	
 }	
+		
+	
+
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/StringLiteral.java

@@ -1,9 +1,13 @@
 
 package de.dhbwstuttgart.syntaxtree.statement;
+import de.dhbwstuttgart.typeinference.Menge;
+// ino.end
+// ino.module.StringLiteral.8653.import 
+import java.util.Hashtable;
+
+import org.apache.bcel.generic.ClassGen;
 
 import de.dhbwstuttgart.typeinference.Menge;
-
-
 import de.dhbwstuttgart.logger.Logger;
 import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
 import de.dhbwstuttgart.syntaxtree.type.GenericTypeVar;
@@ -98,5 +102,11 @@ public class StringLiteral extends Literal
 		return "\""+this.string+"\"";
 	}
 	
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
+   
 }
 // ino.end

src/de/dhbwstuttgart/syntaxtree/statement/This.java

@@ -3,8 +3,10 @@ package de.dhbwstuttgart.syntaxtree.statement;
 // ino.end
 // ino.module.This.8654.import 
 import java.util.Hashtable;
-import de.dhbwstuttgart.typeinference.Menge;
 
+import org.apache.bcel.generic.ClassGen;
+
+import de.dhbwstuttgart.typeinference.Menge;
 import de.dhbwstuttgart.logger.Logger;
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
@@ -140,4 +142,10 @@ public class This extends Expr
 		return ret;
 	}
 
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
+	
 }

src/de/dhbwstuttgart/syntaxtree/statement/WhileStmt.java

@@ -5,10 +5,11 @@ package de.dhbwstuttgart.syntaxtree.statement;
 import java.util.Enumeration;
 import java.util.Hashtable;
 import java.util.Iterator;
+
+import org.apache.bcel.generic.ClassGen;
+
 import de.dhbwstuttgart.typeinference.Menge;
-
 import de.dhbwstuttgart.logger.Logger;
-
 import de.dhbwstuttgart.myexception.CTypeReconstructionException;
 import de.dhbwstuttgart.myexception.JVMCodeException;
 import de.dhbwstuttgart.myexception.SCExcept;
@@ -133,5 +134,11 @@ public class WhileStmt extends Statement
 		ret.add(this.loop_block);
 		return ret;
 	}
+
+	@Override
+	public void genByteCode(ClassGen _cg) {
+		// TODO Auto-generated method stub
+		
+	}
 }
 // ino.end

src/de/dhbwstuttgart/typeinference/ByteCodeResult.java

@@ -1,38 +1,24 @@
 package de.dhbwstuttgart.typeinference;
 
-import de.dhbwstuttgart.typeinference.Menge;
+import org.apache.bcel.generic.ClassGen;
 
+import de.dhbwstuttgart.typeinference.Menge;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 
 public class ByteCodeResult{
 
-	private String byteCode = "";
+	private ClassGen byteCode;
 	//TODO: unresolvedTPHs entfernen. BROKEN!
 	private Menge<TypePlaceholder> unresolvedTPHs = new Menge<TypePlaceholder>();
 	
-	public ByteCodeResult(){
+	public ByteCodeResult(ClassGen byteCode){
-		
+		this.byteCode = byteCode;
 	}
 	
-	public ByteCodeResult(String byteCode){
+	public ClassGen getByteCode(){
-		this.byteCode += byteCode;
-	}
-	
-	public String getByteCode(){
 		return byteCode;
 	}
 	
-	public ByteCodeResult attach(ByteCodeResult byteCodeResult){
-		this.byteCode += byteCodeResult.getByteCode();
-		//Alle TPH anfügen:
-		for(TypePlaceholder tph : byteCodeResult.getUnresolvedTPH())this.addUnresolvedTPH(tph);
-		return this;
-	}
-	
-	public ByteCodeResult attach(String javaCode){
-		this.byteCode += javaCode;
-		return this;
-	}
 
 	public void addUnresolvedTPH(TypePlaceholder typePlaceholder) {
 		unresolvedTPHs.add(typePlaceholder);
@@ -49,7 +35,7 @@ public class ByteCodeResult{
 	
 	@Override
 	public String toString(){
-		return getByteCode();
+		return getByteCode().toString();
 	}
 	
 	@Override

test/bytecode/EmptyClass.jav

@@ -1,2 +1,7 @@
 class EmptyClass{
+
+public EmptyClass(){}
+
+public void leckMichAmArsch(){}
+
 }

test/bytecode/EmptyClass.java

@@ -13,6 +13,7 @@ import plugindevelopment.TypeInsertTester;
 import de.dhbwstuttgart.core.MyCompiler;
 import de.dhbwstuttgart.core.MyCompilerAPI;
 import de.dhbwstuttgart.logger.LoggerConfiguration;
+import de.dhbwstuttgart.logger.Section;
 import de.dhbwstuttgart.parser.JavaParser.yyException;
 import de.dhbwstuttgart.typeinference.ByteCodeResult;
 import de.dhbwstuttgart.typeinference.Menge;
@@ -23,16 +24,18 @@ public class EmptyClass {
 	
 	public final static String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
 	public final static String testFile = "EmptyClass.jav";
+	public final static String outputFile = "EmptyClassTest.class";
 	
 	@Test
 	public void test() {
-		LoggerConfiguration logConfig = new LoggerConfiguration();
+		LoggerConfiguration logConfig = new LoggerConfiguration().setOutput(Section.PARSER, System.out);
 		MyCompilerAPI compiler = MyCompiler.getAPI(logConfig);
 		try {
 			compiler.parse(new File(rootDirectory + testFile));
 			compiler.typeReconstruction();
 			ByteCodeResult bytecode = compiler.generateBytecode();
 			System.out.println(bytecode);
+			bytecode.getByteCode().getJavaClass().dump(new File(rootDirectory + outputFile));
 		} catch (IOException | yyException e) {
 			e.printStackTrace();
 			TestCase.fail();