From f3a324fb3865b3c7287001bd669ff5fb63fbb59b Mon Sep 17 00:00:00 2001 From: stan Date: Wed, 27 May 2015 15:57:15 +0200 Subject: [PATCH 1/7] =?UTF-8?q?genByteCode=20f=C3=BCr=20Constructor=20impl?= =?UTF-8?q?ementiert.=20Unfertig?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/de/dhbwstuttgart/core/MyCompiler.java | 4 ++- src/de/dhbwstuttgart/syntaxtree/Class.java | 32 +++++++++---------- .../dhbwstuttgart/syntaxtree/Constructor.java | 30 ++++++++++++++++- src/de/dhbwstuttgart/syntaxtree/Field.java | 9 +++++- .../syntaxtree/FieldDeclaration.java | 9 +++++- src/de/dhbwstuttgart/syntaxtree/Method.java | 12 +++++-- .../syntaxtree/statement/MethodCall.java | 1 - .../typeinference/ByteCodeResult.java | 28 ++++------------ test/bytecode/EmptyClass.java | 9 ++++-- 9 files changed, 86 insertions(+), 48 deletions(-) diff --git a/src/de/dhbwstuttgart/core/MyCompiler.java b/src/de/dhbwstuttgart/core/MyCompiler.java index 1b776429c..5c066ceea 100755 --- a/src/de/dhbwstuttgart/core/MyCompiler.java +++ b/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; diff --git a/src/de/dhbwstuttgart/syntaxtree/Class.java b/src/de/dhbwstuttgart/syntaxtree/Class.java index 5acd3c003..fecde5472 100755 --- a/src/de/dhbwstuttgart/syntaxtree/Class.java +++ b/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.*; @@ -70,26 +73,21 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I //Method created with BCEL to generate ByteCode public ByteCodeResult genByteCode() throws IOException { - ByteCodeResult code = new ByteCodeResult(); - _cg = new ClassGen(pkgName.get_Name() + "/" + name, superClass.get_Name(), name + ".java", Constants.ACC_PUBLIC , new String[] { }); //new String necessary? + + SectionLogger logger = Logger.getSectionLogger(this.getClass().getName(), Section.CODEGEN); + logger.debug("Test"); + + 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(); - MethodGen method = new MethodGen(Constants.ACC_PUBLIC, org.apache.bcel.generic.Type.VOID, org.apache.bcel.generic.Type.NO_ARGS, new String[] { }, "", pkgName.get_Name() + "." + name, il, _cp); - - InstructionHandle ih_0 = il.append(_factory.createLoad(org.apache.bcel.generic.Type.OBJECT, 0)); //creates Constructor - il.append(_factory.createInvoke("java.lang.Object", "", 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()); - + for(Field field : this.fielddecl){ + field.genByteCode(_cg); + } + + ByteCodeResult code = new ByteCodeResult(_cg); return code; /*ByteCodeResult bc = new ByteCodeResult(); diff --git a/src/de/dhbwstuttgart/syntaxtree/Constructor.java b/src/de/dhbwstuttgart/syntaxtree/Constructor.java index e7b295698..958a0f30b 100644 --- a/src/de/dhbwstuttgart/syntaxtree/Constructor.java +++ b/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,6 +50,26 @@ 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(); + Class parentClass = this.getParentClass(); + //TODO: Hier return type und Argument-Typen dynamisch generieren. return type mittels method.getReturnType() ermitteln + MethodGen method = new MethodGen(Constants.ACC_PUBLIC, org.apache.bcel.generic.Type.VOID, org.apache.bcel.generic.Type.NO_ARGS, new String[] { }, "", parentClass.name, il, _cp); + + InstructionHandle ih_0 = il.append(_factory.createLoad(org.apache.bcel.generic.Type.OBJECT, 0)); //creates Constructor + il.append(_factory.createInvoke(this.getParentClass().superclassid.toString(), "", 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(); + } + + /* @Override public void parserPostProcessing(SyntaxTreeNode parent){ diff --git a/src/de/dhbwstuttgart/syntaxtree/Field.java b/src/de/dhbwstuttgart/syntaxtree/Field.java index 2b40a0859..cfce0dadc 100644 --- a/src/de/dhbwstuttgart/syntaxtree/Field.java +++ b/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,10 @@ 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); } diff --git a/src/de/dhbwstuttgart/syntaxtree/FieldDeclaration.java b/src/de/dhbwstuttgart/syntaxtree/FieldDeclaration.java index b452e3fc4..eefd74824 100644 --- a/src/de/dhbwstuttgart/syntaxtree/FieldDeclaration.java +++ b/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,10 @@ public class FieldDeclaration extends Field{ if(this.getWert()!=null)this.getWert().wandleRefTypeAttributes2GenericAttributes(paralist, new Menge()); //FieldDeclaration hat keine Generischen Variablen, daher leere Liste übergeben } + @Override + public void genByteCode(ClassGen cg) { + // TODO Auto-generated method stub + + } + } diff --git a/src/de/dhbwstuttgart/syntaxtree/Method.java b/src/de/dhbwstuttgart/syntaxtree/Method.java index a288aa98a..88c3478cb 100755 --- a/src/de/dhbwstuttgart/syntaxtree/Method.java +++ b/src/de/dhbwstuttgart/syntaxtree/Method.java @@ -5,10 +5,11 @@ package de.dhbwstuttgart.syntaxtree; 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.core.IItemWithOffset; import de.dhbwstuttgart.core.MyCompiler; import de.dhbwstuttgart.myexception.JVMCodeException; @@ -710,6 +711,13 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable if(!this.parameterlist.equals(equals.parameterlist))return false; return super.equals(obj); } + + @Override + public void genByteCode(ClassGen cg) { + // TODO Auto-generated method stub + + } + } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/MethodCall.java b/src/de/dhbwstuttgart/syntaxtree/statement/MethodCall.java index 764618598..8860f9b25 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/MethodCall.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/MethodCall.java @@ -48,7 +48,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. diff --git a/src/de/dhbwstuttgart/typeinference/ByteCodeResult.java b/src/de/dhbwstuttgart/typeinference/ByteCodeResult.java index e0f2b382f..b83a5d659 100644 --- a/src/de/dhbwstuttgart/typeinference/ByteCodeResult.java +++ b/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 unresolvedTPHs = new Menge(); - public ByteCodeResult(){ - + public ByteCodeResult(ClassGen byteCode){ + this.byteCode = byteCode; } - public ByteCodeResult(String byteCode){ - this.byteCode += byteCode; - } - - public String getByteCode(){ + public ClassGen 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 diff --git a/test/bytecode/EmptyClass.java b/test/bytecode/EmptyClass.java index 44c78d506..affdf31d1 100644 --- a/test/bytecode/EmptyClass.java +++ b/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 = "EmptyClass.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(); + //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(); From 1d9f58b196dd254e4578014283a8a3138f502ceb Mon Sep 17 00:00:00 2001 From: "Fikus, Evelyn (WWI2012D)" Date: Tue, 16 Jun 2015 11:55:15 +0200 Subject: [PATCH 2/7] Notizen und Codeschnipsel GenByteCode --- .classpath | 22 +++--- bin/log4j.xml | 70 +++++++++---------- bin/log4jTesting.xml | 48 ++++++------- src/de/dhbwstuttgart/syntaxtree/Class.java | 16 ++--- .../dhbwstuttgart/syntaxtree/Constructor.java | 53 +++++++------- src/de/dhbwstuttgart/syntaxtree/Field.java | 1 + .../syntaxtree/FieldDeclaration.java | 6 ++ src/de/dhbwstuttgart/syntaxtree/Method.java | 21 +++++- .../syntaxtree/statement/Block.java | 34 ++++++++- .../syntaxtree/statement/Statement.java | 16 ++++- test/bytecode/EmptyClass.jav | 5 ++ test/bytecode/EmptyClass.java | 4 +- 12 files changed, 186 insertions(+), 110 deletions(-) diff --git a/.classpath b/.classpath index f142a181c..fd7ce2652 100755 --- a/.classpath +++ b/.classpath @@ -1,11 +1,11 @@ - - - - - - - - - - - + + + + + + + + + + + diff --git a/bin/log4j.xml b/bin/log4j.xml index 64e7c5dbd..f36fb342a 100755 --- a/bin/log4j.xml +++ b/bin/log4j.xml @@ -1,35 +1,35 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/bin/log4jTesting.xml b/bin/log4jTesting.xml index dc30c2453..ef8492188 100755 --- a/bin/log4jTesting.xml +++ b/bin/log4jTesting.xml @@ -1,24 +1,24 @@ - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/de/dhbwstuttgart/syntaxtree/Class.java b/src/de/dhbwstuttgart/syntaxtree/Class.java index fecde5472..6cb761afc 100755 --- a/src/de/dhbwstuttgart/syntaxtree/Class.java +++ b/src/de/dhbwstuttgart/syntaxtree/Class.java @@ -60,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 parserlog = Logger.getLogger("parser"); + protected static Logger codegenlog = Logger.getLogger("codegen"); + protected static Logger parserlog = Logger.getLogger("parser"); protected UsedId pkgName; protected Modifiers modifiers; protected String name; @@ -72,9 +72,7 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I //Method created with BCEL to generate ByteCode public ByteCodeResult genByteCode() throws IOException { - - - + SectionLogger logger = Logger.getSectionLogger(this.getClass().getName(), Section.CODEGEN); logger.debug("Test"); @@ -90,11 +88,11 @@ public class Class extends GTVDeclarationContext implements AClassOrInterface, I ByteCodeResult code = new ByteCodeResult(_cg); return code; - /*ByteCodeResult bc = new ByteCodeResult(); - _cg = new ClassGen(pkgName.get_Name() + "/" + name, superClass.get_Name(), name + ".java", Constants.ACC_PUBLIC , new String[] { }); + //ByteCodeResult bc = new ByteCodeResult(); + //_cg = new ClassGen(pkgName.get_Name() + "/" + name, superClass.get_Name(), name + ".java", Constants.ACC_PUBLIC , new String[] { }); //_cg zurückgeben - bc.append(BCELByteCodeOutput); - return _cg;*/ + //bc.append(BCELByteCodeOutput); + //return _cg; } private Menge superif = new Menge(); diff --git a/src/de/dhbwstuttgart/syntaxtree/Constructor.java b/src/de/dhbwstuttgart/syntaxtree/Constructor.java index 958a0f30b..f09ccd30c 100644 --- a/src/de/dhbwstuttgart/syntaxtree/Constructor.java +++ b/src/de/dhbwstuttgart/syntaxtree/Constructor.java @@ -58,19 +58,22 @@ public class Constructor extends Method { InstructionList il = new InstructionList(); Class parentClass = this.getParentClass(); //TODO: Hier return type und Argument-Typen dynamisch generieren. return type mittels method.getReturnType() ermitteln - MethodGen method = new MethodGen(Constants.ACC_PUBLIC, org.apache.bcel.generic.Type.VOID, org.apache.bcel.generic.Type.NO_ARGS, new String[] { }, "", parentClass.name, il, _cp); + + //Hier müsste drin stehen: Kreiere einen Block, welcher ein Statement enthält, welches ein Super Statement ist. + + + // MethodGen 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[] { }, "", parentClass.name, il, _cp); - InstructionHandle ih_0 = il.append(_factory.createLoad(org.apache.bcel.generic.Type.OBJECT, 0)); //creates Constructor - il.append(_factory.createInvoke(this.getParentClass().superclassid.toString(), "", 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(); } + // 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){ @@ -82,7 +85,7 @@ public class Constructor extends Method { gtv.parserPostProcessing(this); } } - */ + @Override public ConstraintsSet TYPE(TypeAssumptions ass) { //super.setType(this.getParentClass().getType()); @@ -95,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 getGenericParameter() { @@ -226,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() { @@ -244,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() { @@ -317,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() { @@ -335,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 getChildren() { @@ -360,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() { @@ -418,7 +421,7 @@ public class Constructor extends Method { public Class getParentClass() { return this.methode.getParentClass(); } - */ + } diff --git a/src/de/dhbwstuttgart/syntaxtree/Field.java b/src/de/dhbwstuttgart/syntaxtree/Field.java index cfce0dadc..55c553ac3 100644 --- a/src/de/dhbwstuttgart/syntaxtree/Field.java +++ b/src/de/dhbwstuttgart/syntaxtree/Field.java @@ -179,3 +179,4 @@ public abstract class Field extends GTVDeclarationContext implements TypeInserta */ public abstract void genByteCode(ClassGen cg); } + diff --git a/src/de/dhbwstuttgart/syntaxtree/FieldDeclaration.java b/src/de/dhbwstuttgart/syntaxtree/FieldDeclaration.java index eefd74824..8d321a045 100644 --- a/src/de/dhbwstuttgart/syntaxtree/FieldDeclaration.java +++ b/src/de/dhbwstuttgart/syntaxtree/FieldDeclaration.java @@ -164,4 +164,10 @@ public class FieldDeclaration extends Field{ } + /*@Override + public void genByteCode(ClassGen cg) { + // TODO Auto-generated method stub + + }*/ + } diff --git a/src/de/dhbwstuttgart/syntaxtree/Method.java b/src/de/dhbwstuttgart/syntaxtree/Method.java index 88c3478cb..8d7a8e900 100755 --- a/src/de/dhbwstuttgart/syntaxtree/Method.java +++ b/src/de/dhbwstuttgart/syntaxtree/Method.java @@ -6,7 +6,13 @@ 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; @@ -20,6 +26,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; @@ -714,8 +721,20 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable @Override public void genByteCode(ClassGen cg) { - // TODO Auto-generated method stub + ConstantPoolGen _cp = cg.getConstantPool(); + InstructionFactory _factory = new InstructionFactory(cg, _cp); + InstructionList il = new InstructionList(); + Class parentClass = this.getParentClass(); + //TODO: Hier return type und Argument-Typen dynamisch generieren. return type mittels method.getReturnType() ermitteln + MethodGen 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[] { }, "", parentClass.name, il, _cp); + + //GenByteCode Constructor + + method.setMaxStack(); + method.setMaxLocals(); + cg.addMethod(method.getMethod()); + il.dispose(); } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/Block.java b/src/de/dhbwstuttgart/syntaxtree/statement/Block.java index 639a98c2c..4ab830110 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/Block.java +++ b/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() @@ -79,6 +91,7 @@ public class Block extends Statement } // ino.end + // ino.method.set_Statement.25068.definition @@ -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,23 @@ 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(); + Class parentClass = this.getParentClass(); + //Instructionhandle dynamisch + //Frage: Wenn Block von Statements erbt, und Block selbst keinen BCEL Code besitzt, ist das hier dann nicht eine Sackgasse? + + for(Statement statements : this.statements){ + statements.genByteCode(_cg); + } + + } } // ino.end + + diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/Statement.java b/src/de/dhbwstuttgart/syntaxtree/statement/Statement.java index b844a30fc..70d3e540a 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/Statement.java +++ b/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 diff --git a/test/bytecode/EmptyClass.jav b/test/bytecode/EmptyClass.jav index 29d3c6260..44dfecf21 100644 --- a/test/bytecode/EmptyClass.jav +++ b/test/bytecode/EmptyClass.jav @@ -1,2 +1,7 @@ class EmptyClass{ + +public EmptyClass(){} + +public void leckMichAmArsch(){} + } \ No newline at end of file diff --git a/test/bytecode/EmptyClass.java b/test/bytecode/EmptyClass.java index affdf31d1..5ce92d79b 100644 --- a/test/bytecode/EmptyClass.java +++ b/test/bytecode/EmptyClass.java @@ -24,7 +24,7 @@ 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 = "EmptyClass.class"; + public final static String outputFile = "EmptyClassTest.class"; @Test public void test() { @@ -32,7 +32,7 @@ public class EmptyClass { MyCompilerAPI compiler = MyCompiler.getAPI(logConfig); try { compiler.parse(new File(rootDirectory + testFile)); - //compiler.typeReconstruction(); + compiler.typeReconstruction(); ByteCodeResult bytecode = compiler.generateBytecode(); System.out.println(bytecode); bytecode.getByteCode().getJavaClass().dump(new File(rootDirectory + outputFile)); From 2fac549cf590793d69bfb53d47828f6cde5788c7 Mon Sep 17 00:00:00 2001 From: "Fikus, Evelyn (WWI2012D)" Date: Tue, 16 Jun 2015 13:08:11 +0200 Subject: [PATCH 3/7] =?UTF-8?q?Zus=C3=A4tzliche=20Kommentare=20und=20gerin?= =?UTF-8?q?gf=C3=BCgige=20=C3=84nderungen=20in=20der=20=C3=9Cberlegung?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/de/dhbwstuttgart/syntaxtree/Constructor.java | 11 +++++------ src/de/dhbwstuttgart/syntaxtree/Method.java | 15 ++++++++++----- .../dhbwstuttgart/syntaxtree/statement/Block.java | 12 ++++++------ 3 files changed, 21 insertions(+), 17 deletions(-) diff --git a/src/de/dhbwstuttgart/syntaxtree/Constructor.java b/src/de/dhbwstuttgart/syntaxtree/Constructor.java index f09ccd30c..253788bde 100644 --- a/src/de/dhbwstuttgart/syntaxtree/Constructor.java +++ b/src/de/dhbwstuttgart/syntaxtree/Constructor.java @@ -53,19 +53,18 @@ public class Constructor extends Method { @Override public void genByteCode(ClassGen cg) { - ConstantPoolGen _cp = cg.getConstantPool(); - InstructionFactory _factory = new InstructionFactory(cg, _cp); - InstructionList il = new InstructionList(); + //ConstantPoolGen _cp = cg.getConstantPool(); + //InstructionFactory _factory = new InstructionFactory(cg, _cp); + //InstructionList il = new InstructionList(); Class parentClass = this.getParentClass(); //TODO: Hier return type und Argument-Typen dynamisch generieren. return type mittels method.getReturnType() ermitteln //Hier müsste drin stehen: Kreiere einen Block, welcher ein Statement enthält, welches ein Super Statement ist. - - // MethodGen 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[] { }, "", parentClass.name, il, _cp); + MethodGen 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[] { }, "", parentClass.name, il, _cp); - il.dispose(); + //il.dispose(); } // super statement muss drin sein // stmt genByteCode + im block genByteCode implementieren & dann Hierarchie ausprobieren diff --git a/src/de/dhbwstuttgart/syntaxtree/Method.java b/src/de/dhbwstuttgart/syntaxtree/Method.java index 8d7a8e900..4b2f159af 100755 --- a/src/de/dhbwstuttgart/syntaxtree/Method.java +++ b/src/de/dhbwstuttgart/syntaxtree/Method.java @@ -721,20 +721,25 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable @Override public void genByteCode(ClassGen cg) { - ConstantPoolGen _cp = cg.getConstantPool(); - InstructionFactory _factory = new InstructionFactory(cg, _cp); - InstructionList il = new InstructionList(); + //ConstantPoolGen _cp = cg.getConstantPool(); + //InstructionFactory _factory = new InstructionFactory(cg, _cp); + //InstructionList il = new InstructionList(); Class parentClass = this.getParentClass(); //TODO: Hier return type und Argument-Typen dynamisch generieren. return type mittels method.getReturnType() ermitteln - MethodGen 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[] { }, "", parentClass.name, il, _cp); + //Über Statements iterieren um den Block abzurufen + for(Statement statements : ){ + statements.genByteCode(cg); + } + + MethodGen method = new MethodGen(Constants.ACC_PUBLIC, org.apache.bcel.generic.Type.getReturnType(Constructor.createEmptyMethod(getTypeInformation(), parent).getType().get_Name()), org.apache.bcel.generic.Type.NO_ARGS , new String[] { }, "", parentClass.name, il, _cp); //GenByteCode Constructor method.setMaxStack(); method.setMaxLocals(); cg.addMethod(method.getMethod()); - il.dispose(); + // il.dispose(); } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/Block.java b/src/de/dhbwstuttgart/syntaxtree/statement/Block.java index 4ab830110..47f5a7095 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/Block.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/Block.java @@ -258,17 +258,17 @@ public class Block extends Statement @Override public void genByteCode(ClassGen cg) { - - ConstantPoolGen _cp = cg.getConstantPool(); + //ConstantPoolGen _cp = cg.getConstantPool(); InstructionFactory _factory = new InstructionFactory(cg, _cp); InstructionList il = new InstructionList(); - Class parentClass = this.getParentClass(); //Instructionhandle dynamisch //Frage: Wenn Block von Statements erbt, und Block selbst keinen BCEL Code besitzt, ist das hier dann nicht eine Sackgasse? - for(Statement statements : this.statements){ - statements.genByteCode(_cg); - } + InstructionHandle ih_0 = il.append(_factory.createLoad(org.apache.bcel.generic.Type.OBJECT, 0)); //creates Constructor + il.append(_factory.createInvoke(this.getParentClass().superclassid.toString(), "", 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 + + il.dispose(); } } From e9c6170d1541442594ec148919ffea0409976d75 Mon Sep 17 00:00:00 2001 From: "Fikus, Evelyn (WWI2012D)" Date: Tue, 16 Jun 2015 13:19:01 +0200 Subject: [PATCH 4/7] =?UTF-8?q?Iteration=20=C3=BCber=20Statements=20innerh?= =?UTF-8?q?alb=20method.java?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/de/dhbwstuttgart/syntaxtree/Method.java | 3 ++- src/de/dhbwstuttgart/syntaxtree/statement/Block.java | 7 ++++--- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/src/de/dhbwstuttgart/syntaxtree/Method.java b/src/de/dhbwstuttgart/syntaxtree/Method.java index 4b2f159af..f618ce0c7 100755 --- a/src/de/dhbwstuttgart/syntaxtree/Method.java +++ b/src/de/dhbwstuttgart/syntaxtree/Method.java @@ -728,7 +728,8 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable //TODO: Hier return type und Argument-Typen dynamisch generieren. return type mittels method.getReturnType() ermitteln //Über Statements iterieren um den Block abzurufen - for(Statement statements : ){ + //Muss dafür ein Statement Array erstellt werden, sodass ich über alle Statements in einem Block iterieren kann? + for(Statement statements : block.get_Statement()){ statements.genByteCode(cg); } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/Block.java b/src/de/dhbwstuttgart/syntaxtree/statement/Block.java index 47f5a7095..6ec92ad5e 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/Block.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/Block.java @@ -261,12 +261,13 @@ public class Block extends Statement //ConstantPoolGen _cp = cg.getConstantPool(); InstructionFactory _factory = new InstructionFactory(cg, _cp); InstructionList il = new InstructionList(); - //Instructionhandle dynamisch + //Frage: Wenn Block von Statements erbt, und Block selbst keinen BCEL Code besitzt, ist das hier dann nicht eine Sackgasse? - InstructionHandle ih_0 = il.append(_factory.createLoad(org.apache.bcel.generic.Type.OBJECT, 0)); //creates Constructor + //Instructionhandle dynamisch + InstructionHandle ih_0 = il.append(_factory.createLoad(org.apache.bcel.generic.Type.OBJECT, 0)); il.append(_factory.createInvoke(this.getParentClass().superclassid.toString(), "", 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 + InstructionHandle ih_4 = il.append(_factory.createReturn(org.apache.bcel.generic.Type.VOID)); il.dispose(); From c6502600cc31cf83aad28ad9bebb83810da7c787 Mon Sep 17 00:00:00 2001 From: "Fikus, Evelyn (WWI2012D)" Date: Tue, 16 Jun 2015 13:53:32 +0200 Subject: [PATCH 5/7] =?UTF-8?q?Weitere=20=C3=9Cberlegung=20im=20Bereich=20?= =?UTF-8?q?Constructor=20/=20Method?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/de/dhbwstuttgart/syntaxtree/Constructor.java | 4 ++-- src/de/dhbwstuttgart/syntaxtree/Method.java | 16 +++++++++------- .../dhbwstuttgart/syntaxtree/SyntaxTreeNode.java | 5 ++++- 3 files changed, 15 insertions(+), 10 deletions(-) diff --git a/src/de/dhbwstuttgart/syntaxtree/Constructor.java b/src/de/dhbwstuttgart/syntaxtree/Constructor.java index 253788bde..b775ba2e4 100644 --- a/src/de/dhbwstuttgart/syntaxtree/Constructor.java +++ b/src/de/dhbwstuttgart/syntaxtree/Constructor.java @@ -53,9 +53,9 @@ public class Constructor extends Method { @Override public void genByteCode(ClassGen cg) { - //ConstantPoolGen _cp = cg.getConstantPool(); + ConstantPoolGen _cp = cg.getConstantPool(); //InstructionFactory _factory = new InstructionFactory(cg, _cp); - //InstructionList il = new InstructionList(); + InstructionList il = new InstructionList(); Class parentClass = this.getParentClass(); //TODO: Hier return type und Argument-Typen dynamisch generieren. return type mittels method.getReturnType() ermitteln diff --git a/src/de/dhbwstuttgart/syntaxtree/Method.java b/src/de/dhbwstuttgart/syntaxtree/Method.java index f618ce0c7..e85888593 100755 --- a/src/de/dhbwstuttgart/syntaxtree/Method.java +++ b/src/de/dhbwstuttgart/syntaxtree/Method.java @@ -727,14 +727,16 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable Class parentClass = this.getParentClass(); //TODO: Hier return type und Argument-Typen dynamisch generieren. return type mittels method.getReturnType() ermitteln - //Über Statements iterieren um den Block abzurufen - //Muss dafür ein Statement Array erstellt werden, sodass ich über alle Statements in einem Block iterieren kann? - for(Statement statements : block.get_Statement()){ - statements.genByteCode(cg); - } - MethodGen method = new MethodGen(Constants.ACC_PUBLIC, org.apache.bcel.generic.Type.getReturnType(Constructor.createEmptyMethod(getTypeInformation(), parent).getType().get_Name()), org.apache.bcel.generic.Type.NO_ARGS , new String[] { }, "", parentClass.name, il, _cp); - + //Über Constructor iterieren, um alle Methoden zu bekommen + for(Method methode : ){ + + //Über Statements iterieren um den Block abzurufen + for(Statement statements : block.get_Statement()){ + statements.genByteCode(cg); + } + } + //GenByteCode Constructor method.setMaxStack(); diff --git a/src/de/dhbwstuttgart/syntaxtree/SyntaxTreeNode.java b/src/de/dhbwstuttgart/syntaxtree/SyntaxTreeNode.java index 5a8e494a2..deb03d89b 100644 --- a/src/de/dhbwstuttgart/syntaxtree/SyntaxTreeNode.java +++ b/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(); } + + } From 253ba6518b558b38767ea849469fde937e8867c8 Mon Sep 17 00:00:00 2001 From: "Fikus, Evelyn (WWI2012D)" Date: Tue, 16 Jun 2015 14:23:32 +0200 Subject: [PATCH 6/7] Versuch, MethodGen in Method.java zu implementieren --- src/de/dhbwstuttgart/syntaxtree/Method.java | 1225 ++++++++++--------- 1 file changed, 621 insertions(+), 604 deletions(-) diff --git a/src/de/dhbwstuttgart/syntaxtree/Method.java b/src/de/dhbwstuttgart/syntaxtree/Method.java index e85888593..d0f954ba4 100755 --- a/src/de/dhbwstuttgart/syntaxtree/Method.java +++ b/src/de/dhbwstuttgart/syntaxtree/Method.java @@ -1,5 +1,6 @@ // ino.module.Method.8564.package package de.dhbwstuttgart.syntaxtree; + // ino.end // ino.module.Method.8564.import import java.util.Enumeration; @@ -42,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. - * Problem: Parser kann nicht zwischen Methode und Konstruktor unterscheiden. Daher kann diese Klasse beides sein. Dies wird mit dem ParserPostProcessing behoben. + * Stellt eine Methode dar. Problem: Parser kann nicht zwischen Methode und + * Konstruktor unterscheiden. Daher kann diese Klasse beides sein. Dies wird mit + * dem ParserPostProcessing behoben. + * * @author janulrich * */ @@ -56,619 +56,628 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable // ino.end // ino.class.Method.23482.body { - // ino.attribute.block.23488.declaration - private Block block; - // ino.end - // ino.attribute.parameterlist.23491.declaration - public ParameterList parameterlist = new ParameterList(); - // ino.end - // ino.attribute.exceptionlist.23494.declaration - private ExceptionList exceptionlist; - // ino.end - // ino.attribute.returntype.23497.declaration - private Type returntype; - // ino.end - - // ino.attribute.genericMethodParameters.23500.decldescription type=javadoc - /** - * HOTI 4.5.06 - * Dieser Vektor beinhaltet alle Generischen Typen und v.a. die - * F-Bounded-Generics, die die Methode besitzt - * size()==0, falls es keine gibt - */ - // ino.end - // ino.attribute.genericMethodParameters.23500.declaration - //private Menge genericMethodParameters=new Menge(); - // ino.end - - // ino.attribute.overloadedID.23503.declaration - private int overloadedID; - // ino.end - // ino.attribute.isAbstract.23506.declaration - private boolean isAbstract = false; - // ino.end - // ino.attribute.types_in_parameterlist.23509.declaration - private Menge types_in_parameterlist = new Menge(); - // ino.end - // 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 - // 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){ - super(offset); - } - - public Method(String name, Type returnType, ParameterList parameterList, Block block, GenericDeclarationList gtvDeclarations, int offset){ - this(offset); - /* - if(parameterList != null)parameterList.parserPostProcessing(this); - if(block != null)block.parserPostProcessing(this); - if(gtvDeclarations != null)gtvDeclarations.parserPostProcessing(this); - */ - this.set_Method_Name(name); - this.setParameterList(parameterList); - this.set_Block(block); - this.setGenericParameter(gtvDeclarations); - this.setReturnType(returnType); - } - - /* - // ino.method.setGenericMethodParameters.23521.definition - public void setGenericMethodParameters(Menge genericMethodParameters) - // ino.end - // ino.method.setGenericMethodParameters.23521.body - { - this.genericMethodParameters=genericMethodParameters; - } - // ino.end - // ino.method.getGenericMethodParameters.23524.definition - public Menge getGenericMethodParameters() - // ino.end - // ino.method.getGenericMethodParameters.23524.body - { - return(genericMethodParameters); - } - // ino.end - */ - /* - // ino.method.sc_init_parameterlist.23530.definition - public void sc_init_parameterlist(boolean ext) - // ino.end - // ino.method.sc_init_parameterlist.23530.body - { - DeclId hilf=null; - Menge list; - FormalParameter para; - String typeofpara; - int i=1; - if(this.getParameterList()!=null) //es gibt Parameter, dann: - { - hilf=declid.elementAt(0); - if(ext) - parserlog.debug("Semantik-Check hat in Methode "+hilf.get_Name()+" bergabewerte gefunden:"); - list=this.getParameterList().sc_get_Formalparalist(); //Menge Formalparalist aus FormalParameterList wird zwischen gesichert - for(Enumeration el2=list.elements(); el2.hasMoreElements();) - { - para=el2.nextElement(); - typeofpara=para.getTypeName(); - if(ext) - parserlog.debug(" "+i+". Parameter hat Typ "+typeofpara); - types_in_parameterlist.addElement(typeofpara); //Typ der Parameter werden im Menge abgelegt - i++; - } - } - 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 - // get_ReturnType() auf eigene Gefahr lschen. - // ino.end - - // ino.method.getTypeName.23533.definition - public JavaClassName getTypeName() - // ino.end - // ino.method.getTypeName.23533.body - { - if( this.getType() == null ) - return null; - else - return this.getType().getName(); - } - // ino.end + // ino.attribute.block.23488.declaration + private Block block; + // ino.end + // ino.attribute.parameterlist.23491.declaration + public ParameterList parameterlist = new ParameterList(); + // ino.end + // ino.attribute.exceptionlist.23494.declaration + private ExceptionList exceptionlist; + // ino.end + // ino.attribute.returntype.23497.declaration + private Type returntype; + // ino.end - // ino.method.get_Block.23536.definition - public Block get_Block() - // ino.end - // ino.method.get_Block.23536.body - { - return block; - } - // ino.end - - // ino.method.setReturnType.23539.defdescription type=javadoc - /** - *
Author: Jrg Buerle - * @param type - */ - // ino.end - // ino.method.setReturnType.23539.definition - private void setReturnType(Type type) - // ino.end - // ino.method.setReturnType.23539.body - { - this.returntype = type; - } - // ino.end + // ino.attribute.genericMethodParameters.23500.decldescription type=javadoc + /** + * HOTI 4.5.06 Dieser Vektor beinhaltet alle Generischen Typen und v.a. die + * F-Bounded-Generics, die die Methode besitzt size()==0, falls es keine + * gibt + */ + // ino.end + // ino.attribute.genericMethodParameters.23500.declaration + // private Menge genericMethodParameters=new + // Menge(); + // ino.end - // ino.method.set_Block.23542.definition - public void set_Block( Block blo) - // ino.end - // ino.method.set_Block.23542.body - { - if(blo.getType() == null)blo.setType(this.returntype); - this.block = blo; - } - // ino.end + // ino.attribute.overloadedID.23503.declaration + private int overloadedID; + // ino.end + // ino.attribute.isAbstract.23506.declaration + private boolean isAbstract = false; + // ino.end + // ino.attribute.types_in_parameterlist.23509.declaration + private Menge types_in_parameterlist = new Menge(); + // ino.end + // 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 + // 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.method.set_Modifiers.23545.definition - public void set_Modifiers(Modifiers modif) - // ino.end - // ino.method.set_Modifiers.23545.body - { - declid.firstElement().set_Modifiers(modif); - // this.modi = modif; - } - // ino.end + // ino.end - // ino.method.set_ExceptionList.23548.definition - public void set_ExceptionList(ExceptionList exlist) - // ino.end - // ino.method.set_ExceptionList.23548.body - { - this.exceptionlist = exlist; - } - // ino.end + public Method(int offset) { + super(offset); + } - // ino.method.setParameterList.23551.definition - public void setParameterList( ParameterList paralist ) - // ino.end - // ino.method.setParameterList.23551.body - { - this.parameterlist = paralist; - } - // ino.end + public Method(String name, Type returnType, ParameterList parameterList, + Block block, GenericDeclarationList gtvDeclarations, int offset) { + this(offset); + /* + * if(parameterList != null)parameterList.parserPostProcessing(this); + * if(block != null)block.parserPostProcessing(this); if(gtvDeclarations + * != null)gtvDeclarations.parserPostProcessing(this); + */ + this.set_Method_Name(name); + this.setParameterList(parameterList); + this.set_Block(block); + this.setGenericParameter(gtvDeclarations); + this.setReturnType(returnType); + } - // ino.method.getParameterList.23554.definition - 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
- * @return Die Anzahl der Methoden-Paramater - */ - // ino.end - // ino.method.getParameterCount.23557.definition - public int getParameterCount() - // ino.end - // ino.method.getParameterCount.23557.body - { - if(this.getParameterList() == null) - return 0; - else - return this.getParameterList().getParameterCount(); - } - // ino.end + /* + * // ino.method.setGenericMethodParameters.23521.definition public void + * setGenericMethodParameters(Menge genericMethodParameters) + * // ino.end // ino.method.setGenericMethodParameters.23521.body { + * this.genericMethodParameters=genericMethodParameters; } // ino.end // + * ino.method.getGenericMethodParameters.23524.definition public + * Menge getGenericMethodParameters() // ino.end // + * ino.method.getGenericMethodParameters.23524.body { + * return(genericMethodParameters); } // ino.end + */ + /* + * // ino.method.sc_init_parameterlist.23530.definition public void + * sc_init_parameterlist(boolean ext) // ino.end // + * ino.method.sc_init_parameterlist.23530.body { DeclId hilf=null; + * Menge list; FormalParameter para; String typeofpara; int + * i=1; if(this.getParameterList()!=null) //es gibt Parameter, dann: { + * hilf=declid.elementAt(0); if(ext) + * parserlog.debug("Semantik-Check hat in Methode " + * +hilf.get_Name()+" bergabewerte gefunden:"); + * list=this.getParameterList().sc_get_Formalparalist(); //Menge + * Formalparalist aus FormalParameterList wird zwischen gesichert + * for(Enumeration el2=list.elements(); + * el2.hasMoreElements();) { para=el2.nextElement(); + * typeofpara=para.getTypeName(); if(ext) + * parserlog.debug(" "+i+". Parameter hat Typ "+typeofpara); + * types_in_parameterlist.addElement(typeofpara); //Typ der Parameter werden + * im Menge abgelegt i++; } } 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 + // get_ReturnType() auf eigene Gefahr lschen. + // ino.end - // ino.method.get_ExceptionList.23560.definition - public ExceptionList get_ExceptionList() - // ino.end - // ino.method.get_ExceptionList.23560.body - { - // otth: gibt die Exceptionliste zurueck - return this.exceptionlist; - } - // ino.end - - // ino.method.getOverloadedID.23563.definition - public int getOverloadedID() - // ino.end - // ino.method.getOverloadedID.23563.body - { - return(overloadedID); - } - // ino.end + // ino.method.getTypeName.23533.definition + public JavaClassName getTypeName() + // ino.end + // ino.method.getTypeName.23533.body + { + if (this.getType() == null) + return null; + else + return this.getType().getName(); + } - // ino.method.setOverloadedID.23566.definition - public void setOverloadedID(int overloadedID) - // ino.end - // ino.method.setOverloadedID.23566.body - { - this.overloadedID=overloadedID; - } - // ino.end - + // 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); - return hilf.get_Name(); - } - // ino.end + // ino.method.get_Block.23536.definition + public Block get_Block() + // ino.end + // ino.method.get_Block.23536.body + { + return block; + } - // ino.method.get_Type_Paralist.23578.definition - public Menge get_Type_Paralist() - // ino.end - // ino.method.get_Type_Paralist.23578.body - { - return types_in_parameterlist; - } - // ino.end - - + // ino.end - // ino.method.getLineNumber.23584.definition - public int getLineNumber() - // ino.end - // ino.method.getLineNumber.23584.body - { - return m_LineNumber; - } - // ino.end - - // ino.method.setLineNumber.23587.definition - public void setLineNumber(int lineNumber) - // ino.end - // ino.method.setLineNumber.23587.body - { - m_LineNumber = lineNumber; - } - // ino.end - - // ino.method.getOffset.23590.defdescription type=line - // hinzugef�gt hoth: 07.04.2006 - // ino.end - // ino.method.getOffset.23590.definition - public int getOffset() - // ino.end - // ino.method.getOffset.23590.body - { - return m_Offset; - } - // ino.end - - // ino.method.getVariableLength.23593.definition - public int getVariableLength() - // ino.end - // ino.method.getVariableLength.23593.body - { - return get_Method_Name().length(); - } - // ino.end - - // ino.method.setOffset.23596.defdescription type=line - // hinzugef�gt hoth: 07.04.2006 - // ino.end - // ino.method.setOffset.23596.definition - public void setOffset(int Offset) - // ino.end - // ino.method.setOffset.23596.body - { - m_Offset = Offset; - } - // ino.end + // ino.method.setReturnType.23539.defdescription type=javadoc + /** + *
+ * Author: Jrg Buerle + * + * @param type + */ + // ino.end + // ino.method.setReturnType.23539.definition + private void setReturnType(Type type) + // ino.end + // ino.method.setReturnType.23539.body + { + this.returntype = type; + } - - // ino.method.getTypeLineNumber.23602.defdescription type=javadoc - /** - *
Author: Jrg Buerle - * @return - */ - // ino.end - // ino.method.getTypeLineNumber.23602.definition - public int getTypeLineNumber() - // ino.end - // ino.method.getTypeLineNumber.23602.body - { - return this.getLineNumber(); - } - // ino.end + // ino.end + + // ino.method.set_Block.23542.definition + public void set_Block(Block blo) + // ino.end + // ino.method.set_Block.23542.body + { + if (blo.getType() == null) + blo.setType(this.returntype); + this.block = blo; + } + + // ino.end + + // ino.method.set_Modifiers.23545.definition + public void set_Modifiers(Modifiers modif) + // ino.end + // ino.method.set_Modifiers.23545.body + { + declid.firstElement().set_Modifiers(modif); + // this.modi = modif; + } + + // ino.end + + // ino.method.set_ExceptionList.23548.definition + public void set_ExceptionList(ExceptionList exlist) + // ino.end + // ino.method.set_ExceptionList.23548.body + { + this.exceptionlist = exlist; + } + + // ino.end + + // ino.method.setParameterList.23551.definition + 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() + // 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
+ * + * @return Die Anzahl der Methoden-Paramater + */ + // ino.end + // ino.method.getParameterCount.23557.definition + public int getParameterCount() + // ino.end + // ino.method.getParameterCount.23557.body + { + if (this.getParameterList() == null) + return 0; + else + return this.getParameterList().getParameterCount(); + } + + // ino.end + + // ino.method.get_ExceptionList.23560.definition + public ExceptionList get_ExceptionList() + // ino.end + // ino.method.get_ExceptionList.23560.body + { + // otth: gibt die Exceptionliste zurueck + return this.exceptionlist; + } + + // ino.end + + // ino.method.getOverloadedID.23563.definition + public int getOverloadedID() + // ino.end + // ino.method.getOverloadedID.23563.body + { + return (overloadedID); + } + + // ino.end + + // ino.method.setOverloadedID.23566.definition + public void setOverloadedID(int overloadedID) + // ino.end + // ino.method.setOverloadedID.23566.body + { + 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); + return hilf.get_Name(); + } + + // ino.end + + // ino.method.get_Type_Paralist.23578.definition + public Menge get_Type_Paralist() + // ino.end + // ino.method.get_Type_Paralist.23578.body + { + return types_in_parameterlist; + } + + // ino.end + + // ino.method.getLineNumber.23584.definition + public int getLineNumber() + // ino.end + // ino.method.getLineNumber.23584.body + { + return m_LineNumber; + } + + // ino.end + + // ino.method.setLineNumber.23587.definition + public void setLineNumber(int lineNumber) + // ino.end + // ino.method.setLineNumber.23587.body + { + m_LineNumber = lineNumber; + } + + // ino.end + + // ino.method.getOffset.23590.defdescription type=line + // hinzugef�gt hoth: 07.04.2006 + // ino.end + // ino.method.getOffset.23590.definition + public int getOffset() + // ino.end + // ino.method.getOffset.23590.body + { + return m_Offset; + } + + // ino.end + + // ino.method.getVariableLength.23593.definition + public int getVariableLength() + // ino.end + // ino.method.getVariableLength.23593.body + { + return get_Method_Name().length(); + } + + // ino.end + + // ino.method.setOffset.23596.defdescription type=line + // hinzugef�gt hoth: 07.04.2006 + // ino.end + // ino.method.setOffset.23596.definition + public void setOffset(int Offset) + // ino.end + // ino.method.setOffset.23596.body + { + m_Offset = Offset; + } + + // ino.end + + // ino.method.getTypeLineNumber.23602.defdescription type=javadoc + /** + *
+ * Author: Jrg Buerle + * + * @return + */ + // ino.end + // ino.method.getTypeLineNumber.23602.definition + public int getTypeLineNumber() + // ino.end + // ino.method.getTypeLineNumber.23602.body + { + return this.getLineNumber(); + } + + // ino.end + + // ino.method.toString.23605.defdescription type=javadoc + /** + *
+ * Author: Martin Pl�micke + * + * @return + */ + // ino.end + // ino.method.toString.23605.definition + public String toString() + // ino.end + // ino.method.toString.23605.body + { + 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 innerhalb der Methode + * generiert wird. + */ + // ino.end + // ino.method.setAbstract.23608.definition + public void setAbstract(boolean b) + // ino.end + // ino.method.setAbstract.23608.body + { + isAbstract = b; + } + + // ino.end + + // ino.method.isAbstract.23611.defdescription type=javadoc + /** + * Gibt zurueck, ob ByteCode innerhabl der Methode generiert wird. + */ + // ino.end + // ino.method.isAbstract.23611.definition + public boolean isAbstract() + // ino.end + // ino.method.isAbstract.23611.body + { + return isAbstract; + } + + @Override + public void wandleRefTypeAttributes2GenericAttributes( + Menge classParalist) { + /* + * Menge paralist = new Menge();//Mit den Generischen Typen + * der Methode paralist.addAll(classParalist); + * paralist.addAll(this.genericMethodParameters); + * + * // Zuerst Returntype untersuchen Type returnType=getType(); Type + * pendantReturnType = null; if(returnType instanceof + * RefType)pendantReturnType = + * ((RefType)returnType).findGenericType(paralist, new + * Menge()); //GenericTypeVar + * pendantReturnType=ClassHelper.findGenericType(returnType, + * paralist,genericMethodParameters); if(pendantReturnType!=null){ + * //Wenn generisch, dann modifizieren setReturnType(pendantReturnType); + * } + * + * // Dann parameterlist untersuchen for(int + * par=0;par()); //GenericTypeVar + * pendantPara=ClassHelper.findGenericType + * (fpType,paralist,genericMethodParameters); if(pendantPara!=null){ + * //Wenn generisch, dann modifizieren fp.setType(pendantPara); } } + * + * // Zuletzt alle Lokalen Variablendeklarationen durchgehen + * if(block!=null){ + * block.wandleRefTypeAttributes2GenericAttributes(paralist + * ,genericMethodParameters); } + */ + } + + public void set_Method_Name(String string) { + if (declid.size() == 0) + declid.add(0, new DeclId(string)); + declid.set(0, new DeclId(string)); + } - // ino.method.toString.23605.defdescription type=javadoc - /** - *
Author: Martin Pl�micke - * @return - */ - // ino.end - // ino.method.toString.23605.definition - public String toString() - // ino.end - // ino.method.toString.23605.body - { - 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 - * innerhalb der Methode generiert wird. - */ - // ino.end - // ino.method.setAbstract.23608.definition - public void setAbstract(boolean b) - // ino.end - // ino.method.setAbstract.23608.body - { - isAbstract = b; - } - // ino.end - - // ino.method.isAbstract.23611.defdescription type=javadoc - /** - * Gibt zurueck, ob ByteCode innerhabl der Methode - * generiert wird. - */ - // ino.end - // ino.method.isAbstract.23611.definition - public boolean isAbstract() - // ino.end - // ino.method.isAbstract.23611.body - { - return isAbstract; - } - - @Override - public void wandleRefTypeAttributes2GenericAttributes(Menge classParalist) - { - /* - Menge paralist = new Menge();//Mit den Generischen Typen der Methode - paralist.addAll(classParalist); - paralist.addAll(this.genericMethodParameters); - - // Zuerst Returntype untersuchen - Type returnType=getType(); - Type pendantReturnType = null; - if(returnType instanceof RefType)pendantReturnType = ((RefType)returnType).findGenericType(paralist, new Menge()); - //GenericTypeVar pendantReturnType=ClassHelper.findGenericType(returnType, paralist,genericMethodParameters); - if(pendantReturnType!=null){ //Wenn generisch, dann modifizieren - setReturnType(pendantReturnType); - } - - // Dann parameterlist untersuchen - for(int par=0;par()); - //GenericTypeVar pendantPara=ClassHelper.findGenericType(fpType,paralist,genericMethodParameters); - if(pendantPara!=null){ //Wenn generisch, dann modifizieren - fp.setType(pendantPara); - } - } - - // Zuletzt alle Lokalen Variablendeklarationen durchgehen - if(block!=null){ - block.wandleRefTypeAttributes2GenericAttributes(paralist,genericMethodParameters); - } - */ - } - - public void set_Method_Name(String string) - { - if(declid.size()==0)declid.add(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 - //Generische Parameterdeklarationen den Assumptions anfügen: - for(GenericTypeVar gtv : this.getGenericParameter()){ + localAss.add(ass); // Die globalen Assumptions anhängen + // Generische Parameterdeklarationen den Assumptions anfügen: + 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)&& - !(this.returntype instanceof mycompiler.mytype.Void)){//Sonderfall der Methode: Ihr Typ darf Void definiert werden. - Type replaceType = null; - replaceType = ass.getTypeFor((RefType)this.returntype); - if(replaceType == null)throw new TypeinferenceException("Der Typ "+this.getType().getName()+" ist nicht korrekt",this); - this.returntype = replaceType; - } - */ - //Die Parameter zu den Assumptions hinzufügen: - if(this.parameterlist!=null)for(FormalParameter param : this.parameterlist){ - - param.setType(param.getType().checkTYPE(localAss, this)); - /* - if(param.getType() instanceof RefType) - { - Type replaceType = null; - replaceType = ass.getTypeFor((RefType)param.getType()); - if(replaceType == null) - throw new TypeinferenceException("Der Typ "+param.getType().getName()+" ist nicht korrekt",param); - param.setType(replaceType); + * if(this.returntype!=null && (this.returntype instanceof RefType)&& + * !(this.returntype instanceof mycompiler.mytype.Void)){//Sonderfall + * der Methode: Ihr Typ darf Void definiert werden. Type replaceType = + * null; replaceType = ass.getTypeFor((RefType)this.returntype); + * if(replaceType == null)throw new + * TypeinferenceException("Der Typ "+this + * .getType().getName()+" ist nicht korrekt",this); this.returntype = + * replaceType; } + */ + // Die Parameter zu den Assumptions hinzufügen: + if (this.parameterlist != null) + for (FormalParameter param : this.parameterlist) { + + param.setType(param.getType().checkTYPE(localAss, this)); + /* + * if(param.getType() instanceof RefType) { Type replaceType = + * null; replaceType = ass.getTypeFor((RefType)param.getType()); + * if(replaceType == null) throw new + * TypeinferenceException("Der Typ " + * +param.getType().getName()+" ist nicht korrekt",param); + * param.setType(replaceType); } + */ + + localAss.addAssumption(new ParameterAssumption(param)); } - */ - - 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: - ret.add(new SingleConstraint(this.block.getType().TYPE(localAss, this), this.returntype.TYPE(localAss, this))); + // eine Verknüpfung mit der Type Assumption aus dem Assumption Set + // und dem ermittelten Typ der Methode: + ret.add(new SingleConstraint(this.block.getType().TYPE(localAss, this), + this.returntype.TYPE(localAss, this))); return ret; } - + /** * @author Andreas Stadelmeier, a10023 * @return die TypInformationen der Statements dieser Methode. */ - public String getTypeInformation(){ - if(this.parameterlist!=null)return "Methode "+this.get_Name()+ " Parameter: "+this.parameterlist.getTypeInformation()+", Block: "+this.block.getTypeInformation(); - return "Methode "+this.get_Name()+" : "+this.getType()+", Block: "+this.block.getTypeInformation(); + public String getTypeInformation() { + if (this.parameterlist != null) + 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; } - + /** * Liefert die MethodAssumption zu dieser Methode */ @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(); - this.assumedType = null; - //if((this.get_Method_Name().equals(classmember.getName()) || this.get_Method_Name().equals("")) && ((this.getType().equals(new mycompiler.mytype.Void(0))) || this.getType() instanceof TypePlaceholder)){ - if((this.get_Method_Name().equals(classmember.getName()) || this.get_Method_Name().equals(""))) { - this.set_Method_Name(""); - this.assumedType = new RefType(classmember.getName(),0); - this.setReturnType(this.assumedType); - this.assumedType = new RefType("void",0); - //Return constructorReturnStatement = new Return(0,0); - //constructorReturnStatement.retexpr = - //this.block.statements.add(constructorReturnStatement); - } - //hoth: 06.04.2006 - //durchlaufe Block und suche nach Objektvariablen fuer Offset-Markierung - Iterator fieldVarIterator = assumptions.iterator(); - while (fieldVarIterator.hasNext()) - { - //Wenn ObjektVariable - CTypeAssumption dieAssum = fieldVarIterator.next(); - if(dieAssum instanceof CInstVarTypeAssumption) - { - 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(), this.get_Method_Name(), this.getType(), this.getParameterCount(),this.getLineNumber(),this.getOffset(),new Menge(),this.getGenericMethodParameters()); // Typannahme bauen... - - - //Methode in V_Fields_methods ablegen - //Dabei wird die OverloadedMethodID ermittelt !! - //=> Method setzenuct - - - assumptions.add(methodAssum); - this.setOverloadedID(methodAssum.getHashSetKey().getOverloadedMethodID()); - - - //F�r die V_i: - CTypeAssumptionSet localAssum = new CTypeAssumptionSet(); - - //Bauen... - ParameterList parameterList = this.getParameterList(); - if(parameterList!=null){ - for(int i=0; i()); - //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); - - methodAssum.addParaAssumption(paraAssum); - - // F�r die V_i: - 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()); - localAssum.addElement(varAssum); - //rememberLocals.addElement(varAssum); - } - } - //...und hinzuf�gen: - - assumptions.add(localAssum);//Assumptions für lokale Variablen den Assumptions 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 - this.assumedType = methodAssum.getAssumedType(); - - return assumptions; - */ + * TypeAssumptions assumptions = new TypeAssumptions(); this.assumedType + * = null; //if((this.get_Method_Name().equals(classmember.getName()) || + * this.get_Method_Name().equals("")) && + * ((this.getType().equals(new mycompiler.mytype.Void(0))) || + * this.getType() instanceof TypePlaceholder)){ + * if((this.get_Method_Name().equals(classmember.getName()) || + * this.get_Method_Name().equals(""))) { + * this.set_Method_Name(""); this.assumedType = new + * RefType(classmember.getName(),0); + * this.setReturnType(this.assumedType); this.assumedType = new + * RefType("void",0); //Return constructorReturnStatement = new + * Return(0,0); //constructorReturnStatement.retexpr = + * //this.block.statements.add(constructorReturnStatement); } //hoth: + * 06.04.2006 //durchlaufe Block und suche nach Objektvariablen fuer + * Offset-Markierung Iterator fieldVarIterator = + * assumptions.iterator(); while (fieldVarIterator.hasNext()) { //Wenn + * ObjektVariable CTypeAssumption dieAssum = fieldVarIterator.next(); + * if(dieAssum instanceof CInstVarTypeAssumption) { + * 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(), + * this.get_Method_Name(), this.getType(), + * this.getParameterCount(),this.getLineNumber(),this.getOffset(),new + * Menge(),this.getGenericMethodParameters()); // Typannahme + * bauen... + * + * + * //Methode in V_Fields_methods ablegen //Dabei wird die + * OverloadedMethodID ermittelt !! //=> Method setzenuct + * + * + * assumptions.add(methodAssum); + * this.setOverloadedID(methodAssum.getHashSetKey + * ().getOverloadedMethodID()); + * + * + * //F�r die V_i: CTypeAssumptionSet localAssum = new + * CTypeAssumptionSet(); + * + * //Bauen... ParameterList parameterList = this.getParameterList(); + * if(parameterList!=null){ for(int i=0; + * i()); //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); + * + * methodAssum.addParaAssumption(paraAssum); + * + * // F�r die V_i: 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()); + * localAssum.addElement(varAssum); + * //rememberLocals.addElement(varAssum); } } //...und + * hinzuf�gen: + * + * assumptions.add(localAssum);//Assumptions für lokale Variablen den + * Assumptions 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 this.assumedType = + * methodAssum.getAssumedType(); + * + * return assumptions; + */ } - - + @Override - public void parserPostProcessing(SyntaxTreeNode parent){ - if(this.getType()==null)this.setType(TypePlaceholder.fresh(this)); - //Bei dem Elterntyp der Methode darf es sich nur um eine Klasse handeln, daher Cast ohne Prüfung: - //Class parentClass = (Class)parent; - if(this.returntype == null)this.returntype = TypePlaceholder.fresh(this); + public void parserPostProcessing(SyntaxTreeNode parent) { + if (this.getType() == null) + this.setType(TypePlaceholder.fresh(this)); + // Bei dem Elterntyp der Methode darf es sich nur um eine Klasse + // 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); - if(this.parameterlist != null){ - for(FormalParameter fp : this.parameterlist){ - fp.parserPostProcessing(this); - } - } - for(GenericTypeVar gtv : this.getGenericParameter()){ - gtv.parserPostProcessing(this); - } - */ + * this.returntype.parserPostProcessing(this); if(this.parameterlist != + * null){ for(FormalParameter fp : this.parameterlist){ + * fp.parserPostProcessing(this); } } for(GenericTypeVar gtv : + * this.getGenericParameter()){ gtv.parserPostProcessing(this); } + */ } - + @Override public Menge getChildren() { Menge ret = new Menge(); @@ -678,74 +687,82 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable ret.add(this.returntype); return ret; } - + @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(){ - //Methode und Block teilen sich einen ReturnType: + public Type getType() { + // 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){ - if(!(obj instanceof Method))return false; + public boolean equals(Object obj) { + 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))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; + if ((this.returntype != null && equals.returntype == null)) + return false; + if ((this.returntype == null && equals.returntype != null)) + 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(); + ConstantPoolGen _cp = cg.getConstantPool(); + // InstructionFactory _factory = new InstructionFactory(cg, _cp); + InstructionList il = new InstructionList(); Class parentClass = this.getParentClass(); - //TODO: Hier return type und Argument-Typen dynamisch generieren. return type mittels method.getReturnType() ermitteln + // TODO: Hier return type und Argument-Typen dynamisch generieren. + // return type mittels method.getReturnType() ermitteln + + for (Statement statements : block.get_Statement()) { + statements.genByteCode(cg); + } + MethodGen method = new MethodGen(Constants.ACC_PUBLIC, + org.apache.bcel.generic.Type.getReturnType(Method method.getType() + .get_Name()), org.apache.bcel.generic.Type.NO_ARGS, + new String[] {}, "", parentClass.name, il, _cp); + + // Über Statements iterieren um den Block abzurufen - //Über Constructor iterieren, um alle Methoden zu bekommen - for(Method methode : ){ - - //Über Statements iterieren um den Block abzurufen - for(Statement statements : block.get_Statement()){ - statements.genByteCode(cg); - } - } - - //GenByteCode Constructor - - method.setMaxStack(); - method.setMaxLocals(); - cg.addMethod(method.getMethod()); - // il.dispose(); + + // GenByteCode Constructor + + method.setMaxStack(); + method.setMaxLocals(); + cg.addMethod(method.getMethod()); + // il.dispose(); } - - } // ino.end From c9f1dd2449b7ef32630c3b650392acf478e9a7ef Mon Sep 17 00:00:00 2001 From: "Fikus, Evelyn (WWI2012D)" Date: Tue, 16 Jun 2015 14:58:27 +0200 Subject: [PATCH 7/7] =?UTF-8?q?=C3=9Cberall=20genByteCode=20Methode=20dekl?= =?UTF-8?q?arieren,=20sodass=20Fehler=20verschwinden.=20Korrektur=20Method?= =?UTF-8?q?.java=20und=20Constructor.java?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../dhbwstuttgart/syntaxtree/Constructor.java | 15 +++++---- src/de/dhbwstuttgart/syntaxtree/Method.java | 32 ++++++------------- .../syntaxtree/statement/Assign.java | 15 +++++++-- .../syntaxtree/statement/Binary.java | 13 ++++++-- .../syntaxtree/statement/BoolLiteral.java | 14 ++++++-- .../syntaxtree/statement/CastExpr.java | 12 ++++++- .../syntaxtree/statement/CharLiteral.java | 10 ++++++ .../syntaxtree/statement/DoubleLiteral.java | 12 +++++-- .../syntaxtree/statement/EmptyStmt.java | 12 +++++-- .../syntaxtree/statement/FloatLiteral.java | 11 +++++-- .../syntaxtree/statement/ForStmt.java | 11 +++++-- .../syntaxtree/statement/IfStmt.java | 13 ++++++-- .../syntaxtree/statement/InstVar.java | 11 +++++-- .../syntaxtree/statement/InstanceOf.java | 11 +++++-- .../syntaxtree/statement/IntLiteral.java | 10 +++++- .../statement/LambdaExpression.java | 10 +++++- .../syntaxtree/statement/LocalOrFieldVar.java | 10 +++++- .../syntaxtree/statement/LocalVarDecl.java | 11 +++++-- .../syntaxtree/statement/LongLiteral.java | 12 +++++-- .../syntaxtree/statement/MethodCall.java | 10 +++++- .../syntaxtree/statement/NegativeExpr.java | 11 +++++-- .../syntaxtree/statement/NewArray.java | 11 +++++-- .../syntaxtree/statement/NewClass.java | 11 +++++-- .../syntaxtree/statement/NotExpr.java | 11 +++++-- .../syntaxtree/statement/Null.java | 11 +++++-- .../syntaxtree/statement/PositivExpr.java | 11 +++++-- .../syntaxtree/statement/PostDecExpr.java | 11 +++++-- .../syntaxtree/statement/PostIncExpr.java | 11 +++++-- .../syntaxtree/statement/PreDecExpr.java | 10 ++++-- .../syntaxtree/statement/PreIncExpr.java | 11 +++++-- .../syntaxtree/statement/Return.java | 10 +++++- .../syntaxtree/statement/StringLiteral.java | 11 +++++-- .../syntaxtree/statement/This.java | 10 +++++- .../syntaxtree/statement/WhileStmt.java | 11 +++++-- 34 files changed, 320 insertions(+), 86 deletions(-) diff --git a/src/de/dhbwstuttgart/syntaxtree/Constructor.java b/src/de/dhbwstuttgart/syntaxtree/Constructor.java index b775ba2e4..0635bdbd1 100644 --- a/src/de/dhbwstuttgart/syntaxtree/Constructor.java +++ b/src/de/dhbwstuttgart/syntaxtree/Constructor.java @@ -55,16 +55,17 @@ public class Constructor extends Method { public void genByteCode(ClassGen cg) { ConstantPoolGen _cp = cg.getConstantPool(); //InstructionFactory _factory = new InstructionFactory(cg, _cp); - InstructionList il = new InstructionList(); + InstructionList il = new InstructionList(); //sollte nicht new sein sondern aus Block kommen Class parentClass = this.getParentClass(); - //TODO: Hier return type und Argument-Typen dynamisch generieren. return type mittels method.getReturnType() ermitteln - + //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[] { }, "", parentClass.name, il, _cp); - MethodGen 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[] { }, "", parentClass.name, il, _cp); - - - //il.dispose(); + methode.genByteCode(cg); //Aufrufen um Iteration über Block zu starten + } // super statement muss drin sein // stmt genByteCode + im block genByteCode implementieren & dann Hierarchie ausprobieren diff --git a/src/de/dhbwstuttgart/syntaxtree/Method.java b/src/de/dhbwstuttgart/syntaxtree/Method.java index d0f954ba4..796bb800a 100755 --- a/src/de/dhbwstuttgart/syntaxtree/Method.java +++ b/src/de/dhbwstuttgart/syntaxtree/Method.java @@ -68,7 +68,7 @@ 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 Dieser Vektor beinhaltet alle Generischen Typen und v.a. die @@ -737,31 +737,19 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable @Override public void genByteCode(ClassGen cg) { - ConstantPoolGen _cp = cg.getConstantPool(); - // InstructionFactory _factory = new InstructionFactory(cg, _cp); - InstructionList il = new InstructionList(); - Class parentClass = this.getParentClass(); - // TODO: Hier return type und Argument-Typen dynamisch generieren. - // return type mittels method.getReturnType() ermitteln - + /*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); } - MethodGen method = new MethodGen(Constants.ACC_PUBLIC, - org.apache.bcel.generic.Type.getReturnType(Method method.getType() - .get_Name()), org.apache.bcel.generic.Type.NO_ARGS, - new String[] {}, "", parentClass.name, il, _cp); - - // Über Statements iterieren um den Block abzurufen - - - // GenByteCode Constructor - - method.setMaxStack(); - method.setMaxLocals(); - cg.addMethod(method.getMethod()); - // il.dispose(); } } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/Assign.java b/src/de/dhbwstuttgart/syntaxtree/statement/Assign.java index 03551933c..2bfab538b 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/Assign.java +++ b/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 diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/Binary.java b/src/de/dhbwstuttgart/syntaxtree/statement/Binary.java index 2283b0da3..c71fbe041 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/Binary.java +++ b/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; @@ -210,6 +211,14 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) { ret.add(this.expr2); return ret; } + + + + @Override + public void genByteCode(ClassGen _cg) { + // TODO Auto-generated method stub + + } } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/BoolLiteral.java b/src/de/dhbwstuttgart/syntaxtree/statement/BoolLiteral.java index c2a7eb925..efcd682a7 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/BoolLiteral.java +++ b/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,7 +30,15 @@ public class BoolLiteral extends Literal // ino.end // ino.class.BoolLiteral.25089.body { - // ino.attribute.Bool.25093.declaration + @Override + public void genByteCode(ClassGen _cg) { + // TODO Auto-generated method stub + + } + + + + // ino.attribute.Bool.25093.declaration private boolean Bool; // ino.end // ino.attribute.parserlog.25096.declaration diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/CastExpr.java b/src/de/dhbwstuttgart/syntaxtree/statement/CastExpr.java index d2b0fedd3..710021276 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/CastExpr.java +++ b/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; @@ -117,6 +119,14 @@ public class CastExpr extends UnaryExpr return ret; } + + + @Override + public void genByteCode(ClassGen _cg) { + // TODO Auto-generated method stub + + } + } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/CharLiteral.java b/src/de/dhbwstuttgart/syntaxtree/statement/CharLiteral.java index b0aa0568b..594dc4959 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/CharLiteral.java +++ b/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 paralist, Menge genericMethodParameters) { } + + + @Override + public void genByteCode(ClassGen _cg) { + // TODO Auto-generated method stub + + } } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/DoubleLiteral.java b/src/de/dhbwstuttgart/syntaxtree/statement/DoubleLiteral.java index ca888b976..cd2ac8a02 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/DoubleLiteral.java +++ b/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 ret = new Menge(); return ret; } + + @Override + public void genByteCode(ClassGen _cg) { + // TODO Auto-generated method stub + + } } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/EmptyStmt.java b/src/de/dhbwstuttgart/syntaxtree/statement/EmptyStmt.java index 67c80dc70..a6dc7bbc2 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/EmptyStmt.java +++ b/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(); } + + @Override + public void genByteCode(ClassGen _cg) { + // TODO Auto-generated method stub + + } + } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/FloatLiteral.java b/src/de/dhbwstuttgart/syntaxtree/statement/FloatLiteral.java index ed809fab5..5ad61fa1d 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/FloatLiteral.java +++ b/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 ret = new Menge(); return ret; } + + @Override + public void genByteCode(ClassGen _cg) { + // TODO Auto-generated method stub + + } } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/ForStmt.java b/src/de/dhbwstuttgart/syntaxtree/statement/ForStmt.java index cbbb7075f..723295c3b 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/ForStmt.java +++ b/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 + + } } \ No newline at end of file diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/IfStmt.java b/src/de/dhbwstuttgart/syntaxtree/statement/IfStmt.java index 5e23f141a..559dbcb4b 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/IfStmt.java +++ b/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 diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/InstVar.java b/src/de/dhbwstuttgart/syntaxtree/statement/InstVar.java index a223621db..94e492319 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/InstVar.java +++ b/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 diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/InstanceOf.java b/src/de/dhbwstuttgart/syntaxtree/statement/InstanceOf.java index e000fe247..fae17dbff 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/InstanceOf.java +++ b/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; @@ -114,6 +115,12 @@ public JavaCodeResult printJavaCode(ResultSet resultSet) { ret.add(this.expr); return ret; } + + @Override + public void genByteCode(ClassGen _cg) { + // TODO Auto-generated method stub + + } } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/IntLiteral.java b/src/de/dhbwstuttgart/syntaxtree/statement/IntLiteral.java index e9632e9bd..3c8044821 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/IntLiteral.java +++ b/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 ret = new Menge(); return ret; } + + @Override + public void genByteCode(ClassGen _cg) { + // TODO Auto-generated method stub + + } } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/LambdaExpression.java b/src/de/dhbwstuttgart/syntaxtree/statement/LambdaExpression.java index 133fe6d0f..07d2a1a0d 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/LambdaExpression.java +++ b/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 + + } + } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/LocalOrFieldVar.java b/src/de/dhbwstuttgart/syntaxtree/statement/LocalOrFieldVar.java index 23ada8aac..107c5a3c0 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/LocalOrFieldVar.java +++ b/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 diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/LocalVarDecl.java b/src/de/dhbwstuttgart/syntaxtree/statement/LocalVarDecl.java index 14b7e3fe2..464a692a3 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/LocalVarDecl.java +++ b/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 diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/LongLiteral.java b/src/de/dhbwstuttgart/syntaxtree/statement/LongLiteral.java index cb9f4272e..dcb14c4a1 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/LongLiteral.java +++ b/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 ret = new Menge(); return ret; } + + @Override + public void genByteCode(ClassGen _cg) { + // TODO Auto-generated method stub + + } } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/MethodCall.java b/src/de/dhbwstuttgart/syntaxtree/statement/MethodCall.java index 8860f9b25..3815d88ba 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/MethodCall.java +++ b/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; @@ -301,6 +303,12 @@ public class MethodCall extends Expr public void parserPostProcessing(SyntaxTreeNode parent) { super.parserPostProcessing(parent); } + + @Override + public void genByteCode(ClassGen _cg) { + // TODO Auto-generated method stub + + } } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/NegativeExpr.java b/src/de/dhbwstuttgart/syntaxtree/statement/NegativeExpr.java index 8e84ce7f6..2562c8629 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/NegativeExpr.java +++ b/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 diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/NewArray.java b/src/de/dhbwstuttgart/syntaxtree/statement/NewArray.java index 3349dd04d..6c60bc9cf 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/NewArray.java +++ b/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 diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/NewClass.java b/src/de/dhbwstuttgart/syntaxtree/statement/NewClass.java index 91c7d912b..cb2c69356 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/NewClass.java +++ b/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; @@ -201,6 +202,12 @@ public class NewClass extends Expr } return ret; } + + @Override + public void genByteCode(ClassGen _cg) { + // TODO Auto-generated method stub + + } } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/NotExpr.java b/src/de/dhbwstuttgart/syntaxtree/statement/NotExpr.java index a3cfbb679..d2d2397a2 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/NotExpr.java +++ b/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 diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/Null.java b/src/de/dhbwstuttgart/syntaxtree/statement/Null.java index 325e67277..5cac43a35 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/Null.java +++ b/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(); } + @Override + public void genByteCode(ClassGen _cg) { + // TODO Auto-generated method stub + + } + } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/PositivExpr.java b/src/de/dhbwstuttgart/syntaxtree/statement/PositivExpr.java index ab5b1712d..deb5ccfea 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/PositivExpr.java +++ b/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 diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/PostDecExpr.java b/src/de/dhbwstuttgart/syntaxtree/statement/PostDecExpr.java index 3a006cd07..8996932f6 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/PostDecExpr.java +++ b/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 diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/PostIncExpr.java b/src/de/dhbwstuttgart/syntaxtree/statement/PostIncExpr.java index 1899fe918..ac16826f8 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/PostIncExpr.java +++ b/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 diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/PreDecExpr.java b/src/de/dhbwstuttgart/syntaxtree/statement/PreDecExpr.java index 1f7fd4150..78f6647ba 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/PreDecExpr.java +++ b/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 diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/PreIncExpr.java b/src/de/dhbwstuttgart/syntaxtree/statement/PreIncExpr.java index 49df77d59..6b66c5af9 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/PreIncExpr.java +++ b/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 diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/Return.java b/src/de/dhbwstuttgart/syntaxtree/statement/Return.java index 57ed3ac54..2246614a7 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/Return.java +++ b/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 diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/StringLiteral.java b/src/de/dhbwstuttgart/syntaxtree/statement/StringLiteral.java index f1c9b2ff3..baabb853c 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/StringLiteral.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/StringLiteral.java @@ -3,9 +3,10 @@ package de.dhbwstuttgart.syntaxtree.statement; // 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.myexception.CTypeReconstructionException; import de.dhbwstuttgart.myexception.JVMCodeException; @@ -107,6 +108,12 @@ public class StringLiteral extends Literal Menge ret = new Menge(); return ret; } + + @Override + public void genByteCode(ClassGen _cg) { + // TODO Auto-generated method stub + + } } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/This.java b/src/de/dhbwstuttgart/syntaxtree/statement/This.java index cc13362f3..dfb5f32ab 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/This.java +++ b/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; @@ -139,5 +141,11 @@ public class This extends Expr Menge ret = new Menge(); return ret; } + + @Override + public void genByteCode(ClassGen _cg) { + // TODO Auto-generated method stub + + } } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/WhileStmt.java b/src/de/dhbwstuttgart/syntaxtree/statement/WhileStmt.java index 2de82c392..44d1eca3b 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/WhileStmt.java +++ b/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