diff --git a/src/de/dhbwstuttgart/bytecode/BytecodeTypeFactory.java b/src/de/dhbwstuttgart/bytecode/BytecodeTypeFactory.java new file mode 100644 index 00000000..d55f9daf --- /dev/null +++ b/src/de/dhbwstuttgart/bytecode/BytecodeTypeFactory.java @@ -0,0 +1,93 @@ +package de.dhbwstuttgart.bytecode; + +import de.dhbwstuttgart.syntaxtree.type.BoundedGenericTypeVar; +import de.dhbwstuttgart.syntaxtree.type.GenericTypeVar; +import de.dhbwstuttgart.syntaxtree.type.ObjectType; +import de.dhbwstuttgart.syntaxtree.type.RefType; +import de.dhbwstuttgart.syntaxtree.type.Type; +import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException; + +public class BytecodeTypeFactory { + + /** + * @see https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-FieldType + */ + public static String generateFieldDescriptor(Type t){ + String ret = ""; + if(t instanceof RefType){ + ret += "L" + t.getName().toString().replace('.', '/') + ";"; + }else{ + throw new NotImplementedException(); + } + return ret; + } + + /** + * @see https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-ClassSignature + */ + public static String generateClassSignature(de.dhbwstuttgart.syntaxtree.Class c){ + String ret = ""; + if(c.getGenericParameter() != null && c.getGenericParameter().size() > 0){ + ret += "<"; + for(GenericTypeVar gtv : c.getGenericParameter()){ + ret += generateTypeParameter(gtv); + } + ret += ">"; + } + //Add the SuperClassSignature: + c.getSuperClass(); + ret += generateClassTypeSignature(); + return ret; + } + + public static String generateSuperClassSignature(Type superClass){ + String ret = ""; + //TODO: + throw new NotImplementedException(); + } + + private static String generateTypeParameter(GenericTypeVar gtv){ + String ret = gtv.get_Name() + ":"; + for(ObjectType t : gtv.getBounds()){ + ret += generateReferenceTypeSignature(t); + ret += ":"; + } + ret = ret.substring(0, ret.length()-1); + return ret; + } + + /** + * @see https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-ClassTypeSignature + */ + private static String generateClassTypeSignature(){ + return null; + } + + /** + * @see https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-ReferenceTypeSignature + */ + private static String generateReferenceTypeSignature(Type t){ + if(t instanceof RefType)return generateReferenceTypeSignature((RefType)t); + if(t instanceof GenericTypeVar)return generateReferenceTypeSignature((GenericTypeVar)t); + throw new NotImplementedException(); + } + + private static String generateReferenceTypeSignature(RefType t){ + String ret = "L" + t.get_Name(); + if(t.getParaList() != null && t.getParaList().size() > 0){ + ret += "<"; + for(Type p : t.getParaList()){ + ret += generateReferenceTypeSignature(p); + } + ret+=">"; + } + return ret + ";"; + } + + private static String generateReferenceTypeSignature(GenericTypeVar t){ + String ret = "T" + t.get_Name(); + return ret + ";"; + } + + +} diff --git a/src/de/dhbwstuttgart/bytecode/ClassGenerator.java b/src/de/dhbwstuttgart/bytecode/ClassGenerator.java index 14c12a85..2b8fe81e 100644 --- a/src/de/dhbwstuttgart/bytecode/ClassGenerator.java +++ b/src/de/dhbwstuttgart/bytecode/ClassGenerator.java @@ -20,6 +20,8 @@ import org.apache.bcel.classfile.Signature; import org.apache.bcel.generic.ClassGen; import org.apache.bcel.generic.ConstantPoolGen; +import de.dhbwstuttgart.parser.JavaClassName; +import de.dhbwstuttgart.syntaxtree.type.GenericTypeVar; import de.dhbwstuttgart.syntaxtree.type.RefType; import de.dhbwstuttgart.syntaxtree.type.Type; import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; @@ -36,6 +38,7 @@ public class ClassGenerator extends ClassGen{ private TypeinferenceResults tiResult; private int lambdaMethodeNr = 0; private Type superClass; + private List generics; private Menge usedTPHs = new Menge<>(); @@ -43,11 +46,14 @@ public class ClassGenerator extends ClassGen{ private List methodsNamesAndTypes = new LinkedList<>(); private MethodGenerator methodGenerator; - public ClassGenerator(String name, Type superClass, String string, short accessflags, String[] strings, TypeinferenceResults typeinferenceResults) { - super(name,superClass.get_Name(),string,accessflags,strings, new DHBWConstantPoolGen()); - this.tiResult = typeinferenceResults; + public ClassGenerator(JavaClassName name, Type superClass, List generics, + String sourceFileName, short accessflags, String[] implementedInterfaces, TypeinferenceResults rs) { + super(name.toString(),superClass.get_Name(),sourceFileName,accessflags,implementedInterfaces, new DHBWConstantPoolGen()); + //this.tiResult = typeinferenceResultSet; this.superClass = superClass; + this.generics = generics; + tiResult = rs; cp = (DHBWConstantPoolGen) super.getConstantPool(); factory = new DHBWInstructionFactory(this, cp); this.setMajor(52); //Java 8 Version 52.0 @@ -62,7 +68,7 @@ public class ClassGenerator extends ClassGen{ * Versucht einen Type zu finden von dem dieser TPH ein Subtyp sein muss. * @param toTPH * @return Es gilt dann "toTPH extends Type" - */ + public org.apache.bcel.generic.Type getNearestUsedType(Type t, Menge usedTypes){ if(t == null){ return this.getInstructionFactory().createObjectType(); @@ -70,13 +76,13 @@ public class ClassGenerator extends ClassGen{ //return getNearestType((TypePlaceholder) t); return new TypePlaceholderType((TypePlaceholder) t); }else{ - return t.getBytecodeType(this, getTypeinferenceResults().getTypeReconstructions().get(0)); + return t.getBytecodeType(this, getTypeinferenceResultSet().getTypeReconstructions().get(0)); } } public org.apache.bcel.generic.Type getNearestUsedType(TypePlaceholder toTPH){ return this.getNearestUsedType(toTPH, null); } - + */ public String createLambdaMethodName() { return "lambda$methode$"+(lambdaMethodeNr++); } @@ -152,8 +158,19 @@ public class ClassGenerator extends ClassGen{ //Signatur setzen: String typeParameters = this.generateParameterSignature(); - String superClassSignature = this.superClass.getBytecodeSignature(this, null); - String classSignature = typeParameters + superClassSignature; + String superClassSignature = BytecodeTypeFactory.generateSuperClassSignature(this.superClass);//"L" + this.superClass.getBytecodeType(cg, rs) + superClassSignature = superClassSignature.substring(0, superClassSignature.length()-1); //Das ";" am Ende entfernen + if(this.superClass instanceof RefType && + ((RefType)superClass).get_ParaList() != null && + ((RefType)superClass).get_ParaList().size() > 0){ + superClassSignature += "<"; + RefType superRefType = (RefType) this.superClass; + for(Type param : superRefType.get_ParaList()){ + superClassSignature += param.getBytecodeSignature(this, null); + } + superClassSignature += ">;"; + } + String classSignature = typeParameters + superClassSignature; //TOOD: Hier noch die Signaturen der SuperInterfaces anfügen if(classSignature.length()>0){ this.addAttribute(new Signature(cp.addUtf8("Signature"),2,cp.addUtf8(classSignature),cp.getConstantPool())); } @@ -178,6 +195,16 @@ public class ClassGenerator extends ClassGen{ private String generateParameterSignature(){ String ret = ""; + //ret += "L" + this.getClassName().replace(".", "/") + ";"; + if(this.generics != null && this.generics.size() > 0){ + ret += "<"; + for(GenericTypeVar gtv : this.generics){ + ret += gtv.getBytecodeSignature(this, tiResult.getTypeReconstructions().get(0)); + } + ret += ">"; + } + + /* if(this.getUsedTPH().size()>0){ ret += "<"; Iterator it = ((Menge)this.getUsedTPH().clone()).iterator(); @@ -185,10 +212,11 @@ public class ClassGenerator extends ClassGen{ TypePlaceholder tph = it.next(); //ret += tph.getBytecodeMethodSignature(this); //ret += ":"; - ret += tph.getClassSignature(this, getTypeinferenceResults().getTypeReconstructions().get(0)); + ret += tph.getClassSignature(this, null); //Es wird null übergeben. Die ClassSignaturen dürfen von keinem ResultSet abhängen. } ret += ">"; } + */ return ret; } @@ -199,11 +227,12 @@ public class ClassGenerator extends ClassGen{ public Map getExtraClasses() { return extraClasses; } - - public TypeinferenceResults getTypeinferenceResults() { + /* + public TypeinferenceResults getTypeinferenceResultSet() { return tiResult; } - + */ + @Override public void addMethod(Method m) { //TODO: Die Prüfung, ob Methode bereits vorhanden vor die Bytecodegenerierung verlegen (Beispielsweise in Method) @@ -225,4 +254,5 @@ public class ClassGenerator extends ClassGen{ return methodGenerator; } + } diff --git a/src/de/dhbwstuttgart/core/MyCompiler.java b/src/de/dhbwstuttgart/core/MyCompiler.java index 8116c00c..18103d71 100755 --- a/src/de/dhbwstuttgart/core/MyCompiler.java +++ b/src/de/dhbwstuttgart/core/MyCompiler.java @@ -145,7 +145,7 @@ public class MyCompiler implements MyCompilerAPI{ * Fun0-FunN (momentan für N = 6) * @return */ - private TypeAssumptions makeFunNAssumptions(){ + public static TypeAssumptions makeFunNAssumptions(){ TypeAssumptions ret = new TypeAssumptions(); //Basic Assumptions für die FunN Interfaces: diff --git a/src/de/dhbwstuttgart/syntaxtree/Class.java b/src/de/dhbwstuttgart/syntaxtree/Class.java index 9b5ef495..3f83f2d5 100755 --- a/src/de/dhbwstuttgart/syntaxtree/Class.java +++ b/src/de/dhbwstuttgart/syntaxtree/Class.java @@ -71,13 +71,14 @@ public class Class extends GTVDeclarationContext implements IItemWithOffset, Gen protected Logger typinferenzLog = Logger.getLogger(Class.class.getName()); protected Modifiers modifiers; protected JavaClassName name; - private Menge superif; public Class(JavaClassName name, List methoden, List felder, Modifiers modifier, boolean isInterface, RefType superClass, List implementedInterfaces, int offset){ super(offset); } + protected List implementedInterfaces = new ArrayList<>(); + /** * * @param resultSet - Fehlende Typen im Syntaxbaum werden nach diesem ResultSet aufgelöst @@ -93,8 +94,11 @@ public class Class extends GTVDeclarationContext implements IItemWithOffset, Gen SectionLogger logger = Logger.getSectionLogger(this.getClass().getName(), Section.CODEGEN); logger.debug("Test"); - short constants = Constants.ACC_PUBLIC; //Per Definition ist jede Methode public - _cg = new ClassGenerator(name.toString(), this.getSuperClass(), name.getName() + ".java", constants , new String[] { }, typeinferenceResults); //letzter Parameter sind implementierte Interfaces + if(pkgName != null)throw new NotImplementedException(); + short constants = Const.ACC_PUBLIC; //Per Definition ist jede Methode public + if(isInterface())constants+=Const.ACC_INTERFACE; + + _cg = new ClassGenerator(name, this.getSuperClass(), this.getGenericParameter(), name + ".java", constants , new String[] { }, typeinferenceResults); //letzter Parameter sind implementierte Interfaces _cp = _cg.getConstantPool(); _factory = new DHBWInstructionFactory(_cg, _cp); @@ -108,12 +112,14 @@ public class Class extends GTVDeclarationContext implements IItemWithOffset, Gen if(field instanceof FieldDeclaration)fieldDeclarations.add((FieldDeclaration)field); //field.genByteCode(_cg); } + //Zuerst die Methoden und Felder abarbeiten: for(Method m : methods){ - m.genByteCode(_cg, this); + m.genByteCode(_cg, this, typeinferenceResults); } InstructionList fieldInitializations = new InstructionList(); for(FieldDeclaration f : fieldDeclarations){ + //Die Felder können noch nicht überladen werden. Hier ist nur die erste der Lösungen möglich: fieldInitializations.append(f.genByteCode(_cg, typeinferenceResults.getTypeReconstructions().get(0))); } //Die Konstruktoren müssen die Feld initialisierungswerte beinhalten: @@ -126,7 +132,15 @@ public class Class extends GTVDeclarationContext implements IItemWithOffset, Gen public JavaClassName getName() { - return name; + return new JavaClassName((this.pkgName!=null ? this.pkgName.toString() +"." : "") +this.name); + } + public void setName(String strName) + { + name = new JavaClassName(strName); + } + public void setModifiers(Modifiers mod) + { + this.modifiers = mod; } public Modifiers getModifiers() { @@ -276,9 +290,7 @@ public class Class extends GTVDeclarationContext implements IItemWithOffset, Gen */ public String toString() { - //return superclassid.toString() + body.toString(); - //geaendert PL 07-07-28 - return name.getName(); + return name.toString(); } public String getTypeInformation(Menge methodList, Menge fieldList){ @@ -443,11 +455,6 @@ public class Class extends GTVDeclarationContext implements IItemWithOffset, Gen public String getDescription(){ return "class "+this.getName(); } - @Override - public int getVariableLength() { - // TODO Auto-generated method stub - return 0; - } @Override public void setGenericParameter(GenericDeclarationList params) { @@ -485,10 +492,10 @@ public class Class extends GTVDeclarationContext implements IItemWithOffset, Gen return true; } + protected boolean isInterface; public boolean isInterface(){ - return false; + return isInterface; } - /* private Collection getGenericClasses() { Collection results = new Menge<>(); diff --git a/src/de/dhbwstuttgart/syntaxtree/Constructor.java b/src/de/dhbwstuttgart/syntaxtree/Constructor.java index b4bc8309..457dc35e 100644 --- a/src/de/dhbwstuttgart/syntaxtree/Constructor.java +++ b/src/de/dhbwstuttgart/syntaxtree/Constructor.java @@ -27,6 +27,7 @@ import de.dhbwstuttgart.typeinference.ConstraintsSet; import de.dhbwstuttgart.typeinference.JavaCodeResult; import de.dhbwstuttgart.typeinference.ResultSet; import de.dhbwstuttgart.typeinference.TypeinferenceResultSet; +import de.dhbwstuttgart.typeinference.TypeinferenceResults; import de.dhbwstuttgart.typeinference.assumptions.ConstructorAssumption; import de.dhbwstuttgart.typeinference.assumptions.MethodAssumption; import de.dhbwstuttgart.typeinference.assumptions.ParameterAssumption; @@ -64,9 +65,15 @@ public class Constructor extends Method { DHBWConstantPoolGen _cp = cg.getConstantPool(); InstructionList il = new InstructionList(); //sollte nicht new sein sondern aus Block kommen +<<<<<<< HEAD MethodGenerator method = new MethodGenerator(Constants.ACC_PUBLIC, this.getType().getBytecodeType(cg, null), this.parameterlist.getBytecodeTypeList(cg,null) , this.parameterlist.getParameterNameArray(), "", cg.getClassName(), il, _cp); +======= + MethodGenerator method = new MethodGenerator(Constants.ACC_PUBLIC, + this.getType().getBytecodeType(cg, null), this.parameterlist.getBytecodeTypeList(cg,null), + this.parameterlist.getParameterNameArray(), "", parentClass.name.toString(), il, _cp); +>>>>>>> refactoring //FieldInitializations an Block anfügen Block block = this.get_Block(); @@ -81,7 +88,7 @@ public class Constructor extends Method { @Override - public void genByteCode(ClassGenerator cg, Class classObj) { + public void genByteCode(ClassGenerator cg, Class classObj, TypeinferenceResults resultSets) { this.genByteCode(cg, new InstructionList()); } // super statement muss drin sein diff --git a/src/de/dhbwstuttgart/syntaxtree/FieldDeclaration.java b/src/de/dhbwstuttgart/syntaxtree/FieldDeclaration.java index a3229c77..948adaa1 100644 --- a/src/de/dhbwstuttgart/syntaxtree/FieldDeclaration.java +++ b/src/de/dhbwstuttgart/syntaxtree/FieldDeclaration.java @@ -164,11 +164,5 @@ public class FieldDeclaration extends Field{ il.append(putFieldInstruction ); return il; } - - /*@Override - public void genByteCode(ClassGen cg) { - // TODO Auto-generated method stub - - }*/ } diff --git a/src/de/dhbwstuttgart/syntaxtree/GenericDeclarationList.java b/src/de/dhbwstuttgart/syntaxtree/GenericDeclarationList.java index 30b8333b..583c63de 100644 --- a/src/de/dhbwstuttgart/syntaxtree/GenericDeclarationList.java +++ b/src/de/dhbwstuttgart/syntaxtree/GenericDeclarationList.java @@ -21,9 +21,18 @@ public class GenericDeclarationList extends SyntaxTreeNode implements Iterable gtvs = new Menge<>(); +<<<<<<< HEAD public GenericDeclarationList(List values, int endOffset) { super(endOffset); gtvs = values; +======= + public GenericDeclarationList(){ + this(new Menge(), -1); + } + + public GenericDeclarationList(Menge values, int endOffset) { + this.addAll(values); +>>>>>>> refactoring this.offsetOfLastElement = endOffset; } diff --git a/src/de/dhbwstuttgart/syntaxtree/Method.java b/src/de/dhbwstuttgart/syntaxtree/Method.java index 380267d9..14208d5b 100755 --- a/src/de/dhbwstuttgart/syntaxtree/Method.java +++ b/src/de/dhbwstuttgart/syntaxtree/Method.java @@ -44,6 +44,7 @@ import de.dhbwstuttgart.typeinference.JavaCodeResult; import de.dhbwstuttgart.typeinference.ResultSet; import de.dhbwstuttgart.typeinference.TypeInsertable; import de.dhbwstuttgart.typeinference.TypeinferenceResultSet; +import de.dhbwstuttgart.typeinference.TypeinferenceResults; import de.dhbwstuttgart.typeinference.UndConstraint; import de.dhbwstuttgart.typeinference.assumptions.MethodAssumption; import de.dhbwstuttgart.typeinference.assumptions.ParameterAssumption; @@ -81,7 +82,8 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable super(offset); } - public Method(String name, Type returnType, ParameterList parameterList, Block block, GenericDeclarationList gtvDeclarations, int offset) { + public Method(String name, Type returnType, ParameterList parameterList, Block block, + GenericDeclarationList gtvDeclarations, int offset) { this(offset); this.name = name; this.parameterlist = parameterList; @@ -326,16 +328,21 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable return super.equals(obj); } - public void genByteCode(ClassGenerator cg, Class classObj) { - List typeInterferenceResults = cg.getTypeinferenceResults().getTypeReconstructions(this, cg); + public void genByteCode(ClassGenerator cg, Class classObj, TypeinferenceResults resultSets) { + List typeInterferenceResults = resultSets.getTypeReconstructions(this, cg); DHBWInstructionFactory _factory = cg.getInstructionFactory(); for(TypeinferenceResultSet t: typeInterferenceResults){ addMethodToClassGenerator(cg, _factory, t, classObj); } } +<<<<<<< HEAD private void addMethodToClassGenerator(ClassGenerator cg, DHBWInstructionFactory _factory, TypeinferenceResultSet t, Class parentClass) { +======= + + private void addMethodToClassGenerator(ClassGenerator cg, DHBWInstructionFactory _factory, TypeinferenceResultSet t) { +>>>>>>> refactoring DHBWConstantPoolGen _cp = cg.getConstantPool(); InstructionList il = new InstructionList(); @@ -352,8 +359,14 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable Type returnType = this.getType(); MethodGenerator method = new MethodGenerator(constants, returnType.getBytecodeType(cg, t), +<<<<<<< HEAD argumentTypes.toArray(new org.apache.bcel.generic.Type[parameterlist.size()]) , argumentNames.toArray(new String[parameterlist.size()]), this.get_Name(), parentClass.name.toString(), il, _cp); +======= + argumentTypes.toArray(new org.apache.bcel.generic.Type[parameterlist.size()]) , + argumentNames.toArray(new String[parameterlist.size()]), this.get_Method_Name(), + getParentClass().name.toString(), il, _cp); +>>>>>>> refactoring cg.setMethodeGenerator(method); diff --git a/src/de/dhbwstuttgart/syntaxtree/SourceFile.java b/src/de/dhbwstuttgart/syntaxtree/SourceFile.java index 6e887011..8cf29657 100755 --- a/src/de/dhbwstuttgart/syntaxtree/SourceFile.java +++ b/src/de/dhbwstuttgart/syntaxtree/SourceFile.java @@ -676,227 +676,6 @@ public class SourceFile } //} } - // ino.end - - - // ino.method.makeBasicAssumptions.21418.defdescription type=javadoc - /** - * Erzeugt die Anfangsinformationen �ber bereits bekannte Klassen. - *
Achtung Workaround: Die RefTypes m�ssen sp�ter noch durch BaseTypes - * ersetzt werden.
- * Author: J�rg B�uerle - * - * @return A priori Typinformationen - * @throws ClassNotFoundException - */ - // ino.end - // ino.method.makeBasicAssumptions.21418.definition - private TypeAssumptions makeBasicAssumptions() - // ino.end - // ino.method.makeBasicAssumptions.21418.body - { - /* - if(LOAD_BASIC_ASSUMPTIONS_FROM_JRE){ - - Menge strImports=new Menge(); - ImportDeclarations usedIdImports=getImports(); - for(int i=0;i()); - foo.addFieldOrLocalVarAssumption(instVar); - - meth = new CMethodTypeAssumption(new RefType("java.lang.Integer", 0), "", new RefType("java.lang.Integer",-1), 0,MyCompiler.NO_LINENUMBER,MyCompiler.NO_LINENUMBER,new Menge(),null); - foo.addMethodIntersectionType(new CIntersectionType(meth)); - - meth = new CMethodTypeAssumption(new RefType("java.lang.Integer", 0), "", new RefType("java.lang.Integer",-1),1, MyCompiler.NO_LINENUMBER,MyCompiler.NO_LINENUMBER,new Menge(),null); - meth.addParaAssumption(new CParaTypeAssumption("java.lang.Integer", "", 1, 0,"value", new RefType("java.lang.Integer",-1), MyCompiler.NO_LINENUMBER,MyCompiler.NO_LINENUMBER,new Menge())); - foo.addMethodIntersectionType(new CIntersectionType(meth)); - - meth = new CMethodTypeAssumption(new RefType("java.lang.Integer", 0), "intValue", new RefType("java.lang.Integer",-1), 0,MyCompiler.NO_LINENUMBER,MyCompiler.NO_LINENUMBER,new Menge(),null); - foo.addMethodIntersectionType(new CIntersectionType(meth)); - - - - c = new BasicAssumptionClass("java.lang.Integer", mod); - - // ui = new UsedId(); - // ui.set_Name("Super-Class-Blub"); - // c.set_UsedId(ui); - // pl = new Menge(); - // pl.addElement(new GenericTypeVar("bla")); - // c.set_ParaList(pl); - this.addElement(c); - - //------------------------ - // Boolean bauen: - //------------------------ - foo.addClassName("java.lang.Boolean"); //PL 05-08-01 eingefuegt - meth = new CMethodTypeAssumption(new RefType("java.lang.Boolean", 0), "", new RefType("java.lang.Boolean",-1),0, MyCompiler.NO_LINENUMBER,MyCompiler.NO_LINENUMBER,new Menge(),null); - foo.addMethodIntersectionType(new CIntersectionType(meth)); - - meth = new CMethodTypeAssumption(new RefType("java.lang.Boolean", 0), "", new RefType("java.lang.Boolean",-1), 1,MyCompiler.NO_LINENUMBER,MyCompiler.NO_LINENUMBER,new Menge(),null); - meth.addParaAssumption(new CParaTypeAssumption("java.lang.Boolean", "", 1, 0, "value", new RefType("java.lang.Boolean",-1), MyCompiler.NO_LINENUMBER,MyCompiler.NO_LINENUMBER,new Menge())); - foo.addMethodIntersectionType(new CIntersectionType(meth)); - - meth = new CMethodTypeAssumption(new RefType("java.lang.Boolean", 0), "booleanValue", new RefType("java.lang.Boolean",-1), 0,MyCompiler.NO_LINENUMBER,MyCompiler.NO_LINENUMBER,new Menge(),null); - foo.addMethodIntersectionType(new CIntersectionType(meth)); - - c = new BasicAssumptionClass("java.lang.Boolean", mod); - - // ui = new UsedId(); - // ui.set_Name("Super-Class-Blub"); - // c.set_UsedId(ui); - // pl = new Menge(); - // pl.addElement(new GenericTypeVar("bla")); - // c.set_ParaList(pl); - this.addElement(c); - - //------------------------ - // Character bauen: - //------------------------ - foo.addClassName("java.lang.Character"); //PL 05-08-01 eingefuegt - meth = new CMethodTypeAssumption(new RefType("java.lang.Character", 0), "", new RefType("java.lang.Character",-1),0, MyCompiler.NO_LINENUMBER,MyCompiler.NO_LINENUMBER,new Menge(),null); - foo.addMethodIntersectionType(new CIntersectionType(meth)); - - meth = new CMethodTypeAssumption(new RefType("java.lang.Character", 0), "", new RefType("java.lang.Character",-1),1, MyCompiler.NO_LINENUMBER,MyCompiler.NO_LINENUMBER,new Menge(),null); - meth.addParaAssumption(new CParaTypeAssumption("java.lang.Character", "", 1, 0,"value", new RefType("java.lang.Character",-1), MyCompiler.NO_LINENUMBER,MyCompiler.NO_LINENUMBER,new Menge())); - foo.addMethodIntersectionType(new CIntersectionType(meth)); - - meth = new CMethodTypeAssumption(new RefType("java.lang.Character", 0), "charValue", new BooleanType(),0, MyCompiler.NO_LINENUMBER,MyCompiler.NO_LINENUMBER,new Menge(),null); - foo.addMethodIntersectionType(new CIntersectionType(meth)); - - c = new BasicAssumptionClass("java.lang.Character", mod); - - // ui = new UsedId(); - // ui.set_Name("Super-Class-Blub"); - // c.set_UsedId(ui); - // pl = new Menge(); - // pl.addElement(new GenericTypeVar("bla")); - // c.set_ParaList(pl); - this.addElement(c); - - //------------------------ - // Menge bauen: - //------------------------ - foo.addClassName("java.lang.Menge"); //PL 05-08-01 eingefuegt - TypePlaceholder E = TypePlaceholder.fresh(); // Sp�ter ersetzen durch GenericTypeVar - Menge typeGenPara = new Menge(); - typeGenPara.addElement(new GenericTypeVar(E.getName(),-1)); - foo.addGenericTypeVars("java.lang.Menge", typeGenPara); - meth = new CMethodTypeAssumption(new RefType("java.lang.Menge", 0), "elementAt", new GenericTypeVar(E.getName(),-1), 1,MyCompiler.NO_LINENUMBER,MyCompiler.NO_LINENUMBER,new Menge(),null); - meth.addParaAssumption(new CParaTypeAssumption("java.lang.Menge", "elementAt", 1, 0, "index", new RefType("java.lang.Integer",-1), MyCompiler.NO_LINENUMBER,MyCompiler.NO_LINENUMBER,new Menge())); - foo.addMethodIntersectionType(new CIntersectionType(meth)); - - meth = new CMethodTypeAssumption(new RefType("java.lang.Menge", 0), "addElement", new Void(-1),1, MyCompiler.NO_LINENUMBER,MyCompiler.NO_LINENUMBER,new Menge(),null); - meth.addParaAssumption(new CParaTypeAssumption("java.lang.Menge", "addElement", 1, 0,"element", new GenericTypeVar(E.getName(),-1), MyCompiler.NO_LINENUMBER,MyCompiler.NO_LINENUMBER,new Menge())); - foo.addMethodIntersectionType(new CIntersectionType(meth)); - - meth = new CMethodTypeAssumption(new RefType("java.lang.Menge", 0), "size", new RefType("java.lang.Integer",-1), 0,MyCompiler.NO_LINENUMBER,MyCompiler.NO_LINENUMBER,new Menge(),null); - foo.addMethodIntersectionType(new CIntersectionType(meth)); - - c = new BasicAssumptionClass("java.lang.Menge", mod); - - // ui = new UsedId(); - // ui.set_Name("Super-Class-Blub"); - // c.set_UsedId(ui); - // pl = new Menge(); - // pl.addElement(E); - // c.set_ParaList(pl); - this.addElement(c); - - //------------------------ - // Stack bauen: - //------------------------ - foo.addClassName("java.lang.Stack"); //PL 05-08-01 eingefuegt - c = new BasicAssumptionClass("java.lang.Stack", mod); - ui = new UsedId(-1); - ui.set_Name("java.lang.Menge"); - c.set_UsedId(ui); - // pl = new Menge(); - // pl.addElement(E); - // c.set_ParaList(pl); - this.addElement(c); - - return foo; - */ - TypeAssumptions ret = new TypeAssumptions(); - - //Basic Assumptions für die FunN Interfaces: - //TODO: Hier mehr als Fun1-Fun5 implementieren - for(int i = 0; i<6; i++){ - FunNInterface funN = new FunNInterface(i); - ret.add(funN.getPublicFieldAssumptions()); - } - - return ret; //TODO: Diese TypeAssumptions mit basic-Assumptions füllen - } - // ino.end - - // ino.method.setImports.21421.definition - private void setImports(ImportDeclarations newImports) - // ino.end - // ino.method.setImports.21421.body - { - this.imports=newImports; - - } - // ino.end - - - // ino.method.removeBasicAssumptions.21424.defdescription type=javadoc - /** - * L�scht die Anfangsinformation wieder aus dem Klassenvektor - *
Author: J�rg B�uerle - */ - // ino.end - // ino.method.removeBasicAssumptions.21424.definition - private void removeBasicAssumptions() - // ino.end - // ino.method.removeBasicAssumptions.21424.body - { - for(int i=0; i generateBytecode(TypeinferenceResults results) { @@ -1027,6 +806,22 @@ public class SourceFile for(Class cl : this.KlassenVektor){ ret.add(cl.genByteCode(results)); } + //Alle FunN Klassen erzeugen: + for(ClassAssumption funNAss : MyCompiler.makeFunNAssumptions().getClassAssumptions()){ + ret.add(funNAss.getAssumedClass().genByteCode(results)); + } + /* + //Add all FunN Interfaces + for(Pair ucons : results.getUnifiedConstraints()){ + for(Type t : ucons.getTypes()){ + List xClasses = t.isClassFromJavaX(); + for(Class xClass : xClasses){ + ByteCodeResult bC = xClass.genByteCode(results); + if(! ret.contains(bC))ret.add(bC); + } + } + } + */ return ret; } diff --git a/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java b/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java index 24211f8b..3975fd17 100644 --- a/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java +++ b/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java @@ -9,12 +9,20 @@ import java.util.List; import javax.lang.model.element.Modifier; +======= +import java.util.ArrayList; +import java.util.List; + +>>>>>>> refactoring import de.dhbwstuttgart.bytecode.ClassGenerator; import de.dhbwstuttgart.parser.JavaClassName; import de.dhbwstuttgart.syntaxtree.Class; import de.dhbwstuttgart.syntaxtree.Constructor; import de.dhbwstuttgart.syntaxtree.Field; +<<<<<<< HEAD import de.dhbwstuttgart.syntaxtree.FormalParameter; +======= +>>>>>>> refactoring import de.dhbwstuttgart.syntaxtree.GenericDeclarationList; import de.dhbwstuttgart.syntaxtree.Method; import de.dhbwstuttgart.syntaxtree.ParameterList; @@ -34,11 +42,6 @@ import de.dhbwstuttgart.typeinference.ResultSet; import de.dhbwstuttgart.typeinference.TypeinferenceResultSet; public class ASTFactory { - public static Method createMethod(String name, ParameterList paralist, Block block, Class parent) { - - - return method; - } public static Method createEmptyMethod(String withSignature, Class parent) { return ASTFactory.createMethod(withSignature, new ParameterList(), new Block(), parent); @@ -138,7 +141,6 @@ public class ASTFactory { * @param jreTypeVar * @param inClass Die Klasse in der der Typ auftritt * @return - */ public static GenericTypeVar createGeneric(TypeVariable jreTypeVar, java.lang.Class inClass){ //TODO: Bei den Namen der Parameter des Generishen Typs nachschauen, ob er in der Klasse als Generic deklariert wurde String name = jreTypeVar.getTypeName(); @@ -151,4 +153,23 @@ public class ASTFactory { } return new GenericTypeVar(); } + + */ + + public static Class createInterface(String className, RefType superClass, Modifiers modifiers, + Menge supertypeGenPara, SourceFile parent){ + Class generatedClass = new Class(new JavaClassName(className), new ArrayList(), new ArrayList(), modifiers, + true, superClass, new ArrayList(), new GenericDeclarationList(), -1); + generatedClass.parserPostProcessing(parent); + return generatedClass; + } + + public static Class createObjectClass() { + Class generatedClass = new Class("java.lang.Object", 0); + return generatedClass; + } + + public static RefType createObjectType(){ + return createObjectClass().getType(); + } } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/LambdaExpression.java b/src/de/dhbwstuttgart/syntaxtree/statement/LambdaExpression.java index 85f5327f..220517e2 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/LambdaExpression.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/LambdaExpression.java @@ -1,6 +1,7 @@ package de.dhbwstuttgart.syntaxtree.statement; import java.util.ArrayList; +import java.util.List; import org.apache.bcel.Const; import org.apache.bcel.Constants; @@ -214,6 +215,16 @@ public class LambdaExpression extends Expr{ return ret; } + /* + private List crawlVariables(SyntaxTreeNode inStatements){ + List ret = new ArrayList<>(); + for(SyntaxTreeNode child : inStatements.getChildren()){ + ret.addAll(crawlVariables(child)); + } + return ret; + } + */ + @Override public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs) { DHBWConstantPoolGen cp = cg.getConstantPool(); @@ -296,7 +307,7 @@ public class LambdaExpression extends Expr{ String interfaceMethodName = "apply"; //Das ist ein Hack, funktioniert momentan, da nur FunN Interfaces für LambdaAusdrücke funktionieren //String invokeDynamicType = org.apache.bcel.generic.Type.getMethodSignature(lambdaType.getBytecodeType(cg, rs), additionalParameters); - String invokeDynamicType = org.apache.bcel.generic.Type.getMethodSignature(new org.apache.bcel.generic.ObjectType("Fun0"), additionalParameters); + String invokeDynamicType = org.apache.bcel.generic.Type.getMethodSignature(lambdaType.getBytecodeType(cg, rs), additionalParameters); il.append(cg.getInstructionFactory().createInvokeDynamic(interfaceMethodName,invokeDynamicType, bMethod)); return il; diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/LocalOrFieldVarOrClassname.java b/src/de/dhbwstuttgart/syntaxtree/statement/LocalOrFieldVarOrClassname.java index bb0992e8..c4f75ad4 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/LocalOrFieldVarOrClassname.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/LocalOrFieldVarOrClassname.java @@ -160,11 +160,12 @@ public class LocalOrFieldVarOrClassname extends Expr public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs) { InstructionList il = new InstructionList(); if(this.isFieldAccess){ + il.append(new This(this).genByteCode(cg, rs)); il.append(cg.getInstructionFactory().createFieldAccess(this.getParentClass().getName().toString(), this.get_Name(), this.getType().getBytecodeType(cg, rs), Constants.GETFIELD)); + }else{ + il.append(createLoad(cg, rs)); } - il.append(createLoad(cg, rs)); - return il; } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/MethodCall.java b/src/de/dhbwstuttgart/syntaxtree/statement/MethodCall.java index 97cdc19c..c47a4442 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/MethodCall.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/MethodCall.java @@ -4,6 +4,7 @@ package de.dhbwstuttgart.syntaxtree.statement; // ino.module.MethodCall.8639.import import java.util.Hashtable; +import org.apache.bcel.Const; import org.apache.bcel.Constants; import org.apache.bcel.generic.ClassGen; import org.apache.bcel.generic.InstructionFactory; @@ -333,9 +334,9 @@ public class MethodCall extends Expr de.dhbwstuttgart.syntaxtree.Class receiverClass = this.receiver.getReceiverClass(cg, rs); short kind = 0; if(receiverClass.isInterface()){ - kind = Constants.INVOKEINTERFACE; + kind = Const.INVOKEINTERFACE; }else{//Ansonsten muss es eine Klasse sein: - kind = Constants.INVOKEVIRTUAL; + kind = Const.INVOKEVIRTUAL; } org.apache.bcel.generic.Type[] argumentTypen = org.apache.bcel.generic.Type.NO_ARGS; @@ -353,7 +354,10 @@ public class MethodCall extends Expr } org.apache.bcel.generic.Type returnType = this.getType().getBytecodeType(cg, rs); - il.append(_factory.createInvoke(receiver.getReceiverClass(cg, rs).getName().toString(), this.get_Name(), returnType , argumentTypen, kind)); + il.append(_factory.createInvoke( + receiver.get_Expr().getType().getBytecodeType(cg, rs).toString(), + //receiver.getReceiverClass(cg, rs).getBytecodeType(cg, rs).toString(), + this.get_Name(), returnType , argumentTypen, kind)); return il; } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/Receiver.java b/src/de/dhbwstuttgart/syntaxtree/statement/Receiver.java index 5c1d2bbd..2b0dbb0d 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/Receiver.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/Receiver.java @@ -122,5 +122,6 @@ public class Receiver public JavaCodeResult printJavaCode(ResultSet resultSet) { return new JavaCodeResult().attach(this.get_Expr().printJavaCode(resultSet)); } + } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/type/FunN.java b/src/de/dhbwstuttgart/syntaxtree/type/FunN.java index 0f23816a..f73aa7c3 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/FunN.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/FunN.java @@ -13,6 +13,7 @@ import de.dhbwstuttgart.parser.JavaClassName; import de.dhbwstuttgart.syntaxtree.Method; import de.dhbwstuttgart.syntaxtree.ParameterList; import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; +import de.dhbwstuttgart.syntaxtree.factory.NameGenerator; import de.dhbwstuttgart.typeinference.assumptions.MethodAssumption; import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions; import de.dhbwstuttgart.typeinference.exceptions.DebugException; @@ -50,18 +51,19 @@ public class FunN extends RefType { /** * Spezieller Konstruktor um eine FunN ohne Returntype zu generieren - */ + protected FunN(List list){ super("",0); if(list==null)throw new NullPointerException(); setT(list); this.name = new JavaClassName("Fun"+list.size());//getName(); } + */ /** * Erstellt eine FunN: * FunN - * R und T1 - TparameterCount werden mit TypePlaceholdern besetzt. + * R und T1 - TparameterCount werden mit GenericTypeVars besetzt. * @param parameterCount */ public FunN(int parameterCount) { @@ -69,14 +71,15 @@ public class FunN extends RefType { if(parameterCount<0)throw new RuntimeException("Anzahl der Parameter muss >0 sein"); Menge t = new Menge(); for(int i=0;i T) { - super(T); + super(null,T); + this.setR(new Void(this, -1)); this.name = new JavaClassName("FunVoid"+T.size()); } diff --git a/src/de/dhbwstuttgart/syntaxtree/type/GenericTypeVar.java b/src/de/dhbwstuttgart/syntaxtree/type/GenericTypeVar.java index 6d562856..d7934732 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/GenericTypeVar.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/GenericTypeVar.java @@ -2,9 +2,12 @@ package de.dhbwstuttgart.syntaxtree.type; // ino.end +import java.util.ArrayList; // ino.module.GenericTypeVar.8671.import import java.util.HashMap; import java.util.Iterator; +import java.util.List; + import de.dhbwstuttgart.typeinference.Menge; import de.dhbwstuttgart.typeinference.ConstraintsSet; @@ -22,15 +25,14 @@ import de.dhbwstuttgart.parser.JavaClassName; import de.dhbwstuttgart.syntaxtree.Class; import de.dhbwstuttgart.syntaxtree.GTVDeclarationContext; import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; -// ino.class.GenericTypeVar.26505.description type=javadoc +import de.dhbwstuttgart.syntaxtree.factory.ASTFactory; + /** * TODO: Diese Klasse überarbeiten. Pair genericTypeVar ist nicht implementiert. * @author J�rg B�uerle * @version $Date: 2013/09/22 20:12:53 $ */ public class GenericTypeVar extends ObjectType -// ino.end -// ino.class.GenericTypeVar.26505.body { //Type genericTypeVar; //Menge extendVars = new Menge(); @@ -225,7 +227,14 @@ public class GenericTypeVar extends ObjectType // TODO Bytecode return org.apache.bcel.generic.Type.getType(getSignatureType(null));// new org.apache.bcel.generic.ObjectType("Object"); } - + + public List getBounds() + { + //Gibt eine Liste mit "java.lang.Object" zurück, da jede Generic von Object erbt + ArrayList ret = new ArrayList<>(); + ret.add(ASTFactory.createObjectType()); + return ret; + } } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/type/ObjectType.java b/src/de/dhbwstuttgart/syntaxtree/type/ObjectType.java index b008fc7e..4f1a0f8e 100644 --- a/src/de/dhbwstuttgart/syntaxtree/type/ObjectType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/ObjectType.java @@ -1,5 +1,6 @@ package de.dhbwstuttgart.syntaxtree.type; +import de.dhbwstuttgart.parser.JavaClassName; import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; /** @@ -9,7 +10,7 @@ import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; */ public abstract class ObjectType extends Type { - public ObjectType(String s, int offset) { + public ObjectType(JavaClassName s, int offset) { super(s, offset); } public abstract ObjectType clone(); diff --git a/src/de/dhbwstuttgart/syntaxtree/type/RefType.java b/src/de/dhbwstuttgart/syntaxtree/type/RefType.java index fafe85c9..039bfe18 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/RefType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/RefType.java @@ -96,7 +96,7 @@ public class RefType extends ObjectType implements IMatchable } - /** + /** * Wandelt die Parameter des RefTypes in TPHs um, sofern es sich um Generische Variablen handelt. * @return */ @@ -535,12 +535,9 @@ public class RefType extends ObjectType implements IMatchable @Override public String getBytecodeSignature(ClassGenerator cg, TypeinferenceResultSet rs) { String combinedType = getCombinedType(cg, rs); - if(!combinedType.equals(getName().toString())){ - getSuperWildcardTypes(); - Class generatedClass = ASTFactory.createClass(getCombinedType(cg, rs), getGenericClassType(), null, null, new SourceFile()); - - cg.addExtraClass(generatedClass.genByteCode(new TypeinferenceResults()).getByteCode()); - } + /* + + */ String ret = new org.apache.bcel.generic.ObjectType(combinedType).getSignature(); return ret; } @@ -548,32 +545,48 @@ public class RefType extends ObjectType implements IMatchable public String getCombinedType(ClassGenerator cg, TypeinferenceResultSet rs){ //Bsp.: Ljava/util/Vector; StringBuilder sb = new StringBuilder(); - + String ret; + List newParams = new ArrayList<>(); if(parameter != null && parameter.size() > 0){ sb.append(getName().toString().replace(".", "%")); sb.append("%%"); for(Type type: parameter){ + Type newParameter; if(type instanceof RefType){ sb.append(((RefType) type).getCombinedType(cg, rs).replace(".", "%")); + newParameter = type; }else if(type instanceof TypePlaceholder){ + newParameter = rs.getTypeOfPlaceholder((TypePlaceholder)type); sb.append(((TypePlaceholder) type).getBytecodeType(cg, rs).toString().replace(".", "%")); }else if(type instanceof WildcardType){ + //TODO: unresolved! return this.getName().toString(); }else{ + newParameter = type; sb.append(type.getBytecodeType(cg, rs).toString().replace(".", "%")); } - + newParams.add(newParameter); sb.append("%"); } - return sb.toString(); - } - - return sb.append(this.getName().toString()).toString(); + ret = sb.toString(); + }else{ + ret = sb.append(this.getName().toString()).toString(); + } + if(!ret.equals(getName().toString())){ + //getSuperWildcardTypes(); + RefType superClass = new RefType(this.getName(),newParams,this.getOffset()); + Class generatedClass = ASTFactory.createInterface(ret, superClass, null, null, new SourceFile()); + + cg.addExtraClass(generatedClass.genByteCode(new TypeinferenceResults()).getByteCode()); + } + return ret; } + /* public GenericClassType getGenericClassType(){ return new GenericClassType(getName().toString(), getParaList(), parent, getOffset()); } + */ } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/type/Type.java b/src/de/dhbwstuttgart/syntaxtree/type/Type.java index 90eefc36..9a59dd48 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/Type.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/Type.java @@ -3,6 +3,7 @@ package de.dhbwstuttgart.syntaxtree.type; // ino.end // ino.module.Type.8677.import import java.util.ArrayList; +import java.util.List; import de.dhbwstuttgart.typeinference.Menge; import de.dhbwstuttgart.bytecode.ClassGenerator; @@ -26,16 +27,9 @@ public abstract class Type extends SyntaxTreeNode implements IItemWithOffset protected JavaClassName name; private int offset; - public Type(String s, int offset) - { - this.offset = offset; - this.name = new JavaClassName(s); - } - // ino.end - - public Type(JavaClassName s, int offset) { + super(offset); this.offset = offset; this.name = s; } @@ -290,5 +284,15 @@ public abstract class Type extends SyntaxTreeNode implements IItemWithOffset public String getClassSignature(ClassGenerator cg, TypeinferenceResultSet rs){ return this.getBytecodeSignature(cg, rs); } + + /** + * Wird beim Bytecode gebraucht. + * Einige Klassen werden vom Compiler als gegeben angenommen, + * obwohl sie sich nicht in der Java Standard Library befinden. + * Diese müssen beim generieren von Bytecode als zusätzliche Klassen generiert werden. + * + * @return - Eine Liste der Klassen, welche bei Verwendung dieses Typs zusätzlich gebraucht werden. + */ + //public abstract List isClassFromJavaX(); } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/type/TypePlaceholder.java b/src/de/dhbwstuttgart/syntaxtree/type/TypePlaceholder.java index 9867532c..7f69b210 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/TypePlaceholder.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/TypePlaceholder.java @@ -40,9 +40,7 @@ public class TypePlaceholder extends ObjectType // ino.class.TypePlaceholder.26780.body { private static final Logger log = Logger.getLogger(TypePlaceholder.class.getName()); - // ino.attribute.strNextName.26785.declaration - // ino.end - // ino.attribute.m_TypePlaceholdersRegistry.26788.declaration + private static Hashtable m_TypePlaceholdersRegistry = new Hashtable(); // ino.end private SyntaxTreeNode parent; @@ -61,14 +59,12 @@ public class TypePlaceholder extends ObjectType */ private TypePlaceholder(String typeName, SyntaxTreeNode parent) { - super(typeName, -1); + super(new JavaClassName(typeName), -1); if(typeName == null)throw new NullPointerException(); this.name = new JavaClassName(typeName); if(parent != null)log.debug("Erstelle TPH "+typeName+" für SyntaxTreeNode: "+parent, Section.TYPEINFERENCE); } - // ino.end - // ino.method.getInstance.26797.defdescription type=javadoc /** * Statische Methode, um einen TypePlaceholder aus der Registry zu holen. *
Author: J�rg B�uerle @@ -76,15 +72,10 @@ public class TypePlaceholder extends ObjectType * @return Der TypePlaceholder oder null, falls er nicht in der * Registry existiert */ - // ino.end - // ino.method.getInstance.26797.definition public static TypePlaceholder getInstance(String name) - // ino.end - // ino.method.getInstance.26797.body { return m_TypePlaceholdersRegistry.get(name); } - // ino.end /** * Generiert einen neuen TPH mit einem bestimmten Namen. @@ -93,8 +84,6 @@ public class TypePlaceholder extends ObjectType * @return */ public static TypePlaceholder fresh(String name, SyntaxTreeNode parent) - // ino.end - // ino.method.fresh.26800.body { TypePlaceholder typeVar = new TypePlaceholder(name, parent); TypePlaceholder oldTPH = m_TypePlaceholdersRegistry.put(typeVar.getName().toString(), typeVar); @@ -104,7 +93,6 @@ public class TypePlaceholder extends ObjectType } return typeVar; } - // ino.end /** @@ -127,17 +115,12 @@ public class TypePlaceholder extends ObjectType return ret; } - // ino.method.equals.26812.defdescription type=javadoc /** * Author: J�rg B�uerle
* @param Object * @return */ - // ino.end - // ino.method.equals.26812.definition public boolean equals(Object obj) - // ino.end - // ino.method.equals.26812.body { if(obj instanceof TypePlaceholder){ return this.toString().equals(((TypePlaceholder)obj).toString()); @@ -147,27 +130,18 @@ public class TypePlaceholder extends ObjectType return false; } } - // ino.end - - // ino.method.deleteRegistry.26839.defdescription type=javadoc /** * L�scht die komplette Registry von TypePlaceholders. Sollte nur und * ausschlie�lich von MyCompiler.init() aufgerufen werden!!! *
Author: J�rg B�uerle */ - // ino.end - // ino.method.deleteRegistry.26839.definition public static void deleteRegistry() - // ino.end - // ino.method.deleteRegistry.26839.body { m_TypePlaceholdersRegistry.clear(); m_TypePlaceholdersRegistry = new Hashtable(); } - // ino.end - // ino.method.clone.26842.defdescription type=javadoc /** * Diese Methode sollte nur sehr sparsam und mit Vorsicht verwendet werden, da die * Registrierung neuer Listener �ber die zentrale Instanz in der Registry laufen @@ -178,16 +152,11 @@ public class TypePlaceholder extends ObjectType *
Author: J�rg B�uerle * @return */ - // ino.end - // ino.method.clone.26842.definition public TypePlaceholder clone() - // ino.end - // ino.method.clone.26842.body { TypePlaceholder dolly = new TypePlaceholder(name.toString(), this.parent); return dolly; } - // ino.end /** * @author Andreas Stadelmeier, a10023 @@ -198,14 +167,10 @@ public class TypePlaceholder extends ObjectType return getName().toString(); } - // ino.method.toString.26845.definition public String toString() - // ino.end - // ino.method.toString.26845.body { return "TPH " + this.getName(); } - // ino.end /////////////////////////////////////////////////////////////////// // Spezialfunktionen, f�r makeFC() und unify() @@ -269,11 +234,7 @@ public class TypePlaceholder extends ObjectType * @param name * @return */ - // ino.end - // ino.method.backdoorCreate.26854.definition public static TypePlaceholder backdoorCreate(String name) - // ino.end - // ino.method.backdoorCreate.26854.body { //PL 05-08-22 SEHR GEFAEHRLICH @@ -286,7 +247,7 @@ public class TypePlaceholder extends ObjectType //return new TypePlaceholder(name); } - // ino.end + /////////////////////////////////////////////////////////////////// // Ende Spezialfunktionen /////////////////////////////////////////////////////////////////// @@ -350,6 +311,10 @@ public class TypePlaceholder extends ObjectType @Override public String getBytecodeSignature(ClassGenerator cg, TypeinferenceResultSet rs) { + if(rs == null){ + System.out.println(""); + return null; + } Type resolvedType = rs.getTypeOfPlaceholder(this); if(resolvedType instanceof TypePlaceholder){ cg.addUsedTPH((TypePlaceholder)resolvedType); @@ -366,7 +331,8 @@ public class TypePlaceholder extends ObjectType ret+=":"; Menge possibleTPHs = cg.getUsedTPH(); possibleTPHs.remove(this); - org.apache.bcel.generic.Type nearestType = cg.getNearestUsedType(this, possibleTPHs); + //TODO: hier komplett überarbeiten. Wann wird ein TPH eine generische Variable, das sollte geklärt werden. + org.apache.bcel.generic.Type nearestType = null;//cg.getNearestUsedType(this, possibleTPHs); //if(nearestType instanceof TypePlaceholderType){ //Handelt es sich um einen weiteren TPH als nächsten Typ, so ist es ein allgemeiner Typ und wir nehmen Object als Superklasse if(nearestType == null){ ret += cg.getInstructionFactory().createObjectType().getSignature(); @@ -377,4 +343,3 @@ public class TypePlaceholder extends ObjectType } } -// ino.end diff --git a/test/bytecode/IdTest.java b/test/bytecode/IdTest.java index f5da1ab2..e7185ca5 100644 --- a/test/bytecode/IdTest.java +++ b/test/bytecode/IdTest.java @@ -18,4 +18,4 @@ public class IdTest extends SourceFileBytecodeTest{ Object obj = cls.newInstance(); assertTrue(true); } -} \ No newline at end of file +} diff --git a/test/bytecode/Identity.jav b/test/bytecode/Identity.jav index 28bdd3d1..4524c60b 100644 --- a/test/bytecode/Identity.jav +++ b/test/bytecode/Identity.jav @@ -1,4 +1,7 @@ class Identity{ op = (x)->x; +m(){ + op.apply(1); + } } \ No newline at end of file diff --git a/test/bytecode/LambdaExpr.jav b/test/bytecode/LambdaExpr.jav index 882f8f9e..3339ec0e 100644 --- a/test/bytecode/LambdaExpr.jav +++ b/test/bytecode/LambdaExpr.jav @@ -1,9 +1,9 @@ class LambdaExpr { - void method() { + method() { lambda; - lambda = () -> 1; - + lambda = (Integer a) -> a; + return lambda; } } \ No newline at end of file diff --git a/test/bytecode/SingleClassTester.java b/test/bytecode/SingleClassTester.java index 2f731e5c..07564f55 100644 --- a/test/bytecode/SingleClassTester.java +++ b/test/bytecode/SingleClassTester.java @@ -38,21 +38,18 @@ public class SingleClassTester { Menge bytecode = compiler.generateBytecode(sourceFiles, results); //System.out.println(bytecode); - for(ByteCodeResult result: bytecode){ + for(ByteCodeResult result: bytecode){ JavaClass javaClass = result.getByteCode().getJavaClass(); javaClass.dump(new File(outputDirectory+javaClass.getClassName()+".class")); - + ///* for(ClassGenerator cg: result.getByteCode().getExtraClasses().values()){ JavaClass jc = cg.getJavaClass(); jc.dump(new File(outputDirectory+jc.getClassName()+".class")); } - + //*/ Logger.getLogger("SingleClassTester").error(result.getByteCode().getJavaClass().toString(), Section.CODEGEN); - } - - } catch (IOException | yyException e) { Logger.getLogger("SingleClassTester").error(e.toString(), Section.CODEGEN); diff --git a/test/bytecode/SourceFileBytecodeTest.java b/test/bytecode/SourceFileBytecodeTest.java index 3cf8ce2a..d975c0c1 100644 --- a/test/bytecode/SourceFileBytecodeTest.java +++ b/test/bytecode/SourceFileBytecodeTest.java @@ -4,6 +4,8 @@ import static org.junit.Assert.*; import java.io.File; import java.io.IOException; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; import java.net.MalformedURLException; import java.net.URL; import java.net.URLClassLoader; @@ -60,4 +62,13 @@ public abstract class SourceFileBytecodeTest extends TestCase{ return new URLClassLoader(urls); } + + protected void testMethod(String methodName) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException{ + Class testClass = getClassToTest(); + for(Method m : testClass.getMethods()){ + if(m.getName().equals(methodName)){ + m.invoke(testClass, new Object[0]); + } + } + } } diff --git a/test/bytecode/lambda/Simple.jav b/test/bytecode/lambda/Simple.jav new file mode 100644 index 00000000..d29da619 --- /dev/null +++ b/test/bytecode/lambda/Simple.jav @@ -0,0 +1,8 @@ +class Simple{ + +op = (i)->i; + +public void main(){ + op.apply(1); +} +} \ No newline at end of file diff --git a/test/bytecode/lambda/SimpleTest.java b/test/bytecode/lambda/SimpleTest.java new file mode 100644 index 00000000..9ca78037 --- /dev/null +++ b/test/bytecode/lambda/SimpleTest.java @@ -0,0 +1,19 @@ +package bytecode.lambda; + +import org.junit.Test; + +import bytecode.SourceFileBytecodeTest; + +public class SimpleTest extends SourceFileBytecodeTest{ + @Override + protected void init() { + testName = "Simple"; + rootDirectory = System.getProperty("user.dir")+"/test/bytecode/lambda/"; + } + + @Test + public void testConstruct() throws Exception{ + this.testMethod("main"); + assertTrue(true); + } +} diff --git a/test/bytecode/lambda/Test.java b/test/bytecode/lambda/Test.java new file mode 100644 index 00000000..70efddea --- /dev/null +++ b/test/bytecode/lambda/Test.java @@ -0,0 +1,5 @@ +class Test{ + public static void main(String[] args){ + new Simple().main(); +} +} diff --git a/test/bytecode/lambda/TestInterface.java b/test/bytecode/lambda/TestInterface.java new file mode 100644 index 00000000..5b92f6c9 --- /dev/null +++ b/test/bytecode/lambda/TestInterface.java @@ -0,0 +1 @@ +interface TestInterface extends Fun1{} diff --git a/test/plugindevelopment/TypeInsertTests/Id.jav b/test/plugindevelopment/TypeInsertTests/Id.jav index 54a930cf..91d9acef 100644 --- a/test/plugindevelopment/TypeInsertTests/Id.jav +++ b/test/plugindevelopment/TypeInsertTests/Id.jav @@ -1,4 +1,8 @@ -class Id{ - op = (x)->x; -} +class Id { + op = (x) -> x; + +m(){ + op.apply(1); + } +}